Tweaked always-follow alts to follow even for 0 tags

Changed always-follow alts that we use to terminated grow/shrink/remove
operations to use `altle 0xfff0` instead of `altgt 0`.

`altgt 0` gets the job done as long as you make sure tag 0 never ends up
in an rbyd query. But this kept showing up as a problem, and recent
debugging revealed some erronous 0 tag lookups created vestigial alt
pointers (not necessarily a problem, but space-wasting).

Since we moved to a strict 16-bit tag, making these `altle 0xfff0`
doesn't really have a downside, and means we can expect rbyd lookups
around 0 to behave how one would normally expect.

As a (very minor) plus, the value zero usually has special encodings in
instruction sets, so being able to use it for rbyd_lookups offers a
(very minor) code size saving.

---

Sidenote: The reasons altle/altgt is how it is and asymmetric:

1. Flipping these alts is a single bit-flip, which only happens if they
   are asymmetric (only one includes the equal case).

2. Our branches are biased to prefer the larger tag. This makes
   traversal trivial. It might be possible to make this still work with
   altlt/altge, but would require some increments/decrements, which
   might cause problems with boundary conditions around the 16-bit tag
   limit.

scripts/dbgbtree.py

@@ -309,7 +309,7 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
             while True:
                 # first lookup id/name
                 (done, name_tag, rid_, w,
-                    name_j, name_d, name) = rbyd.lookup(TAG_NAME, rid)
+                    name_j, name_d, name) = rbyd.lookup(0, rid)
                 if done:
                     return (True, id, 0, rbyd, -1, 0,
                         0, 0, b'',