Middle of a rewrite for 3-leb encoding, but rbyd appends and creates both work

If we combine rbyd ids and B-tree weights, we need 32-bit ids since this
will eventually need to cover the full range of a file. This simply
doesn't fit into a single word anymore, unless littlefs uses 64-bit tags.
Generally not a great idea for a filesystem targeting even 8-bit
microcontrollers.

So here is a tag encoding that uses 3 leb128 words. This will likely
have more code cost and slightly more disk usage (we can no longer fit
tags into 2 bytes), though with most tags being alt pointers (O(m log m)
vs O(m)), this may not be that significant.

Note that we try to keep tags limited to 14-bits to avoid an extra leb128 byte,
which would likely affect all alt pointers. To pull this off we do away
with the subtype/suptype distinction, limiting in-tree tag types to
10-bits encoded on a per-suptype basis:

  in-tree tags:
                       ttttttt ttt00rv
                                 ^--^^- 10-bit type
                                    '|- removed bit
                                     '- valid bit
  iiii iiiiiii iiiiiii iiiiiii iiiiiii
                                     ^- n-bit id
       lllllll lllllll lllllll lllllll
                                     ^- m-bit length

  out-of-tree tags:
                       ttttttt ttt010v
                                 ^---^- 10-bit type
                                     '- valid bit
                               0000000
       lllllll lllllll lllllll lllllll
                                     ^- m-bit length

  alt tags:
                       kkkkkkk kkk1dcv
                                 ^-^^^- 10-bit key
                                   '||- direction bit
                                    '|- color bit
                                     '- valid bit
  wwww wwwwwww wwwwwww wwwwwww wwwwwww
                                     ^- n-bit weight
       jjjjjjj jjjjjjj jjjjjjj jjjjjjj
                                     ^- m-bit jump

The real pain is that with separate integers for id and tag, it no
longer makes sense to combine these into one big weight field. This
requires a significant rewrite.

lfs_util.h

@@ -114,13 +114,33 @@ static inline uint32_t lfs_min(uint32_t a, uint32_t b) {
     return (a < b) ? a : b;
 }
 
+// TODO how many of these do we actually need
+// Swap two 16-bit numbers
+static inline void lfs_swap16(uint16_t *a, uint16_t *b) {
+    uint16_t t = *a;
+    *a = *b;
+    *b = t;
+}
+
+static inline void lfs_swaps16(int16_t *a, int16_t *b) {
+    int16_t t = *a;
+    *a = *b;
+    *b = t;
+}
+
 // Swap two 32-bit numbers
-static inline void lfs_swap(uint32_t *a, uint32_t *b) {
+static inline void lfs_swap32(uint32_t *a, uint32_t *b) {
     uint32_t t = *a;
     *a = *b;
     *b = t;
 }
 
+static inline void lfs_swaps32(int32_t *a, int32_t *b) {
+    int32_t t = *a;
+    *a = *b;
+    *b = t;
+}
+
 // Align to nearest multiple of a size
 static inline uint32_t lfs_aligndown(uint32_t a, uint32_t alignment) {
     return a - (a % alignment);