Add structured decoding

[frankmcsherry]

Written with Claude, this adds a structured form of decoding that does not use iteration, as this proves to be hard to fully elide when not used. The type DecodedStore essentially provides random access to slices, and could be generalized in the future with a trait that does something like this (not std::ops::Index, because the lifetimes would be too short).

Claude says:

  Summary

  Introduces DecodedStore, a zero-allocation view into indexed-encoded &[u64]
   data that provides O(1) random access to individual slices. The new
  FromBytes::from_store method uses it to give each field independent access
  at its compile-time-known offset, replacing the iterator-based from_u64s
  path.

  The key difference from the iterator approach: each field's access is
  independent — no sequential dependency, no iterator state to advance. This
  lets LLVM fully eliminate unused fields when only one field of a tuple is
  accessed.

  Assembly: critical-path instructions to access one field

  Accessing field 0 of a k-tuple of u64 columns, from raw &[u64] to returned
  value:

  ┌─────────────┬────────────────────────┬──────────────────────┐
  │ Tuple width │  from_bytes (before)   │  from_store (after)  │
  ├─────────────┼────────────────────────┼──────────────────────┤
  │ k=3         │ 133 insns, 14 branches │ 49 insns, 3 branches │
  ├─────────────┼────────────────────────┼──────────────────────┤
  │ k=8         │ 273 insns, 29 branches │ 49 insns, 3 branches │
  ├─────────────┼────────────────────────┼──────────────────────┤
  │ k=16        │ 545 insns, 56 branches │ 49 insns, 3 branches │
  └─────────────┴────────────────────────┴──────────────────────┘

  Constant in k, constant in field position (49 for field 0, 54 for any other
   field). LLVM eliminates unused fields across all type combinators —
  tuples, Results, Options, Vecs, Strings, and arbitrary nesting.

  ┌────────────────────────┬───────────────────┬────────────┬────────────┐
  │          Type          │     Accessing     │ from_bytes │ from_store │
  ├────────────────────────┼───────────────────┼────────────┼────────────┤   
  │ (u64, u64, u64)        │ f0                │ 133 / 14   │ 49 / 3     │
  ├────────────────────────┼───────────────────┼────────────┼────────────┤   
  │ (u64 x8)               │ f0                │ 273 / 29   │ 49 / 3     │
  ├────────────────────────┼───────────────────┼────────────┼────────────┤
  │ (u64 x16)              │ f0                │ 545 / 56   │ 49 / 3     │
  ├────────────────────────┼───────────────────┼────────────┼────────────┤
  │ (u64, Result<u64,u64>) │ f0, skip Result   │ 132 / 11   │ 49 / 3     │
  ├────────────────────────┼───────────────────┼────────────┼────────────┤
  │ (u64, String, Vec)     │ f0, skip          │ 133 / 14   │ 49 / 3     │
  │                        │ String+Vec        │            │            │
  ├────────────────────────┼───────────────────┼────────────┼────────────┤
  │ (u64, (u64, (u64,      │ innermost field   │ 133 / 14   │ 54 / 4     │
  │ u64)))                 │                   │            │            │
  ├────────────────────────┼───────────────────┼────────────┼────────────┤
  │ ((u64 x4), (u64 x4))   │ .1.3              │ 273 / 29   │ 54 / 4     │
  └────────────────────────┴───────────────────┴────────────┴────────────┘

  (Format: critical-path instructions / branches. The from_bytes column does
  not have a k=16 Result measurement but would be proportionally larger.)


  Changes

  - DecodedStore: two-field struct (index and words), constructed in O(1),
  provides .get(k) -> (&[u64], u8) with non-panicking random access
  - FromBytes::from_store: new method with overrides for all types in the
  library, used by Stash::borrow
  - Removes from_u64s, decode_u64s, and from_byte_slices (all superseded)
  - Adds from_store to the derive macro for structs and enums