Made data read functions "consume" their data pointers

Composable parsing functions always feel a bit weird to me in C. I don't
know if this is because of something C lacks, such as multiple return
values, or if composable parsers are just inherently awkward to describe
in procedural languages because of the different levels of state.

But I think the API here is pretty ok. The main idea is that data
parsers can be added as functions in the lfsr_data_* namespace that take
lfsr_data_t as a mutable reference, updating the lfsr_data_t's internal
state as data is parsed.

In practice you only need a couple of primitives, bytes, le32s, leb128s,
that touch the internals of lfsr_data_t, and the other parsers can be
built using these.

This leverages the pointer-like abstraction of lfsr_data_t, and avoids
needing to keep track of offsets. And thanks to lfsr_data_t being
relatively cheap to make copies, this API is relatively flexible.

Some other tweaks:

- Signed leb128 overflow detection is moved up into lfs_fromleb128.
  littlefs now assumes _all_ leb128s are 31-bits, which is useful for
  leveraging the sign bit internally.

  This also fixes the an issue in overflow detection in lfs_fromleb128
  which wouldn't catch overflows in the last byte of a >32-bit leb128.

- Most lfsr_data_t functions now take a pointer. This offered a small
  bit of code savings and feels more natural in C. Though most functions
  that accept lfsr_data_t still take a copy. Most of these functions
  would need to make a copy anyways now that the parsers are consuming,
  and these copies avoid concerns about shared state.

  At 3-words, lfsr_data_t is right at that boundary of questionable
  reasonableness for copying, but copying is a very useful feature of
  this struct.

This ends up with some decent code/stack savings:

            code          stack
  before:  22118           2048
  after:   21722 (-1.8%)   1992 (-2.7%)

lfs_util.h

@@ -330,11 +330,11 @@ static inline uint32_t lfs_fromle32_(const void *buffer) {
 
 // Convert to/from leb128 encoding
 // TODO should we really be using ssize_t here and not lfs_ssize_t?
-ssize_t lfs_toleb128(uint32_t word, void *buffer, size_t size);
+ssize_t lfs_toleb128(int32_t word, void *buffer, size_t size);
 
-ssize_t lfs_fromleb128(uint32_t *word, const void *buffer, size_t size);
+ssize_t lfs_fromleb128(int32_t *word, const void *buffer, size_t size);
 
-static inline size_t lfs_sizeleb128(uint32_t word) {
+static inline size_t lfs_sizeleb128(int32_t word) {
     // this is the size of the leb128 after encoding
     return (lfs_nlog2(word+1)+7-1) / 7;
 }