Implemented file sync broadcasting

Now, when files are synced, they broadcast their disk changes to any other
opened file handles. In effect, all open files match disk after a sync
call to any opened file handle pointing to that file.

This was a much requested feature, as the previous behavior (multiple
opened file handles maintain independent snapshots) is pretty different
from other filesystems. It's also quite difficult to implement outside
of the filesystem, since you need to track all opened files, requiring
either unbounded RAM or a known upper limit.

---

A bit unrelated, but this commit also changes bshrub estimate
calculation to include all opened file handles. This adds some annoying
complexity, but is necessary to prevent sporadic ERANGE errors when
the same file is opened multiple times.

The current implementation just refetches on-disk metadata. This adds
some maybe unnecessary metadata lookups, but simplifies things by
avoiding the tracking of on-disk sprout/shrub size, which risks falling
out of date. Keep in mind we only recalculate the estimate every
~inline_size/2 bytes written.

Just like lfsr_mdir_estimate, this scales O(n^2) with the number of
opened files (this are basically the same function... hmmm... can they
be deduplicated?). This is unlikely to be a problem for littlefs's use
case, but just something to be aware of.

Code changes:

            code          stack
  before:  32920           3032
  after:   33192 (+0.8%)   3048 (+0.5%)

runners/bench_runner.h

@@ -156,7 +156,7 @@ intmax_t bench_define(size_t define);
     BENCH_DEF(BLOCK_COUNT,        DISK_SIZE/BLOCK_SIZE                      ) \
     BENCH_DEF(DISK_SIZE,          1024*1024                                 ) \
     BENCH_DEF(CACHE_SIZE,         lfs_max(16, lfs_max(READ_SIZE, PROG_SIZE))) \
-    BENCH_DEF(INLINE_SIZE,        BLOCK_SIZE/8                              ) \
+    BENCH_DEF(INLINE_SIZE,        BLOCK_SIZE/4                              ) \
     BENCH_DEF(SHRUB_SIZE,         INLINE_SIZE                               ) \
     BENCH_DEF(FRAGMENT_SIZE,      CACHE_SIZE                                ) \
     BENCH_DEF(CRYSTAL_THRESH,     BLOCK_SIZE/8                              ) \

runners/test_runner.h

@@ -142,7 +142,7 @@ intmax_t test_define(size_t define);
     TEST_DEF(BLOCK_COUNT,        DISK_SIZE/BLOCK_SIZE                       ) \
     TEST_DEF(DISK_SIZE,          1024*1024                                  ) \
     TEST_DEF(CACHE_SIZE,         lfs_max(16, lfs_max(READ_SIZE, PROG_SIZE)) ) \
-    TEST_DEF(INLINE_SIZE,        BLOCK_SIZE/8                               ) \
+    TEST_DEF(INLINE_SIZE,        BLOCK_SIZE/4                               ) \
     TEST_DEF(SHRUB_SIZE,         INLINE_SIZE                                ) \
     TEST_DEF(FRAGMENT_SIZE,      CACHE_SIZE                                 ) \
     TEST_DEF(CRYSTAL_THRESH,     BLOCK_SIZE/8                               ) \