Adopted lookupleaf, reworked internal btree APIs

This was a surprising side-effect the script rework: Realizing the
internal btree/rbyd lookup APIs were awkwardly inconsistent and could be
improved with a couple tweaks:

- Adopted lookupleaf name for functions that return leaf rbyds/mdirs.

  There's an argument this should be called lookupnextleaf, since it
  returns the next bid, unlike lookup, but I'm going to ignore that
  argument because:

  1. A non-next lookupleaf doesn't really make sense for trees where
     you don't have to fetch the leaf (the mtree)

  2. It would be a bit too verbose

- Adopted commitleaf name for functions that accept leaf rbyds.

  This makes the lfsr_bshrub_commit -> lfsr_btree_commit__ mess a bit
  more readable.

- Strictly limited lookup and lookupnext to return rattrs, even in
  complex trees like the mtree.

  Most use cases will probably stick to the lookupleaf variants, but at
  least the behavior will be consistent.

- Strictly limited lookup to expect a known bid/rid.

  This only really matters for lfsr_btree/bshrub_lookup, which as a
  quirk of their implementation _can_ lookup both bid + rattr at the
  same time. But I don't think we'll need this functionality, and
  limited the behavior may allow for future optimizations.

  Note there is no lfsr_file_lookup. File btrees currently only ever
  have a single leaf rattr, so this API doesn't really make sense.

Internal API changes:

- lfsr_btree_lookupnext_ -> lfsr_btree_lookupleaf
- lfsr_btree_lookupnext  -> lfsr_btree_lookupnext
- lfsr_btree_lookup      -> lfsr_btree_lookup
- added                     lfsr_btree_namelookupleaf
- lfsr_btree_namelookup  -> lfsr_btree_namelookup
- lfsr_btree_commit__    -> lfsr_btree_commit_
- lfsr_btree_commit_     -> lfsr_btree_commitleaf
- lfsr_btree_commit      -> lfsr_btree_commit

- added                     lfsr_bshrub_lookupleaf
- lfsr_bshrub_lookupnext -> lfsr_bshrub_lookupnext
- lfsr_bshrub_lookup     -> lfsr_bshrub_lookup
- lfsr_bshrub_commit_    -> lfsr_bshrub_commitleaf
- lfsr_bshrub_commit     -> lfsr_bshrub_commit

- lfsr_mtree_lookup      -> lfsr_mtree_lookupleaf
- added                     lfsr_mtree_lookupnext
- added                     lfsr_mtree_lookup
- added                     lfsr_mtree_namelookupleaf
- lfsr_mtree_namelookup  -> lfsr_mtree_namelookup

- added                     lfsr_file_lookupleaf
- lfsr_file_lookupnext   -> lfsr_file_lookupnext
- added                     lfsr_file_commitleaf
- lfsr_file_commit       -> lfsr_file_commit

Also added lookupnext to Mdir/Mtree in the dbg scripts.

Unfortunately this did add both code and stack, but only because of the
optional mdir returns in the mtree lookups:

           code          stack          ctx
  before: 35520           2440          636
  after:  35548 (+0.1%)   2472 (+1.3%)  636 (+0.0%)

scripts/dbgmtree.py

@@ -1477,6 +1477,30 @@ class Mdir:
         rbyd = Rbyd.fetch(bd, blocks, trunk)
         return cls(mid, rbyd, mbits=Mtree.mbits_(bd))
 
+    def lookupnext(self, mid, tag=None, *,
+            path=False):
+        # this is similar to rbyd lookupnext, we just error if
+        # lookupnext changes mids
+        if not isinstance(mid, Mid):
+            mid = Mid(mid, mbits=self.mbits)
+        r = self.rbyd.lookupnext(mid.mrid, tag,
+                path=path)
+        if path:
+            rid, rattr, path_ = r
+        else:
+            rid, rattr = r
+
+        if rid != mid.mrid:
+            if path:
+                return None, path_
+            else:
+                return None
+
+        if path:
+            return rattr, path_
+        else:
+            return rattr
+
     def lookup(self, mid, tag=None, mask=None, *,
             path=False):
         if not isinstance(mid, Mid):
@@ -1777,6 +1801,40 @@ class Mtree:
         else:
             return mdir
 
+    def lookupnext(self, mid, *,
+            path=False,
+            depth=None):
+        if not isinstance(mid, Mid):
+            mid = self.mid(mid)
+
+        # lookup the relevant mdir
+        r = self.lookupleaf(mid,
+                path=path,
+                depth=depth)
+        if path:
+            mdir, path_ = r
+        else:
+            mdir = r
+        if mdir is None:
+            if path:
+                return None, None, path_
+            else:
+                return None, None
+
+        # not in mdir?
+        if mid.mrid >= mdir.weight:
+            if path:
+                return None, None, path_
+            else:
+                return None, None
+
+        # lookup mid in mdir
+        rattr = mdir.lookupnext(mid)
+        if path:
+            return mdir, rattr, path_+[(mid, mdir, rattr)]
+        else:
+            return mdir, rattr
+
     def lookup(self, mid, *,
             path=False,
             depth=None):
@@ -1804,18 +1862,12 @@ class Mtree:
             else:
                 return None, None
 
-        # lookup name in mdir
-        name = mdir.lookup(mid)
-        # name tag missing? weird
-        if name is None:
-            if path:
-                return None, None, path_
-            else:
-                return None, None
+        # lookup mid in mdir
+        rattr = mdir.lookup(mid)
         if path:
-            return mdir, name, path_+[(mid, mdir, name)]
+            return mdir, rattr, path_+[(mid, mdir, rattr)]
         else:
-            return mdir, name
+            return mdir, rattr
 
     # iterate over all mdirs, this includes the mrootchain
     def _leaves(self, *,