Increased mleaf-bits to account for better compaction algorithms

As defined previously, mleaf-bits depended on the attr estimate, which
depended on the details of our compaction algorithm:

      block_size
  m = ----------
          a_0

Assuming t=4, the _minimum_ tag encoding:

      block_size   block_size
  m = ---------- = ----------
        3*4 + 4        16

However, with our new compaction algorithm, our attr estimate changes:

      block_size    block_size   block_size
  m = ---------- = ----------- = ----------
          a_1      (5/2)*4 + 2       12

But tying our mleaf-bits to our attr estimate is a bit fragile. Unlike
attr estimate, the calculated mleaf-bits MUST be the same across all
littlefs implementations, or else the filesystem may not be mountable.

We _could_ store mleaf-bits as an fs attr in the mroot, like we do with
name-limit, size-limit, block-size, etc, but I'd prefer to not add fs
attrs unless strictly required. Each fs attr adds complexity to mounting,
which has a non-zero cost and headache.

Instead, we can assume our compaction algorithm is perfect:

      block_size   block_size   block_size
  m = ---------- = ---------- = ----------
         a_inf         2*4           8

This isn't actually achievable without unbounded RAM. But just because
our current implementation is limited to bounded RAM, does not prevent
some other implementation from pushing things further with unbounded
RAM.

In theory, since this is a perfect compaction algorithm, and builds
perfect rbyd trunks, this should be the maximum possible mleaf-bits
achievable in littlefs's current design, and should be compatible with
any future implementation.

---

Worst case, we can always add mleaf-bits as an fs attr retroactively
without breaking backwards compatibility. You would just need to assume
the above block_size-dependent value if the hypothetical mleaf-bits attr
is missing.

This is one nice thing about our fs attr system, it's very flexible.

scripts/dbgbmap.py

@@ -1344,7 +1344,7 @@ def main(disk, mroots=None, *,
         # determine the mleaf_weight from the block_size, this is just for
         # printing purposes
         if mleaf_weight is None:
-            mleaf_weight = 1 << m.ceil(m.log2(block_size // 16))
+            mleaf_weight = 1 << m.ceil(m.log2(block_size // 8))
 
         #### traverse the filesystem