format: bound and batch every chunk fetch over Storage

Only the full read split its chunk fetches into 64 MiB batches. The
selection path, the indexed read and the parallel_read decoders fetched
every chunk's stored bytes in one read_ranges call, each extent bounded only
by the file length, so a crafted chunk index pointing many chunks at one
large extent made File::open_storage hold chunks x extent bytes (3.3 GB from
a 16.8 MB file) before the first decode error.

- storage::for_each_extent_batch is now the one way raw-data reads fetch
  chunk bytes: batches of at most RAW_BATCH_BYTES (now pub), each decoded
  before the next is fetched. Used by the full, cached, indexed, selection
  and parallel_read paths; the sweep read uses read_extent per chunk.
- ExtentReq carries each chunk's claimed extent (bounds-checked as before,
  same errors) and the prefix actually fetched:
  filters::stored_chunk_limit — the chunk size if unfiltered, else each
  applied filter's worst-case growth (n + n/4 + 4096 per codec; unbounded
  only for an application-registered codec). The in-memory path cuts the
  slice it decodes the same way, so both paths still agree.
- tests/raw_fetch_bounds.rs: a crafted chunked_large.h5 (ten chunks all
  claiming 20 MiB at one padding blob) read through every path over a
  storage that records the largest single fetch; and 160 MiB of legitimate
  unfiltered chunks fetched batch by batch. Before: one 80 MiB fetch
  (selection) and one 160 MiB fetch; after: within the budget.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

docs/design/range-reads.md

@@ -435,8 +435,12 @@ fast path within benchmark noise.
     (checked: identical conformance results; the bench gate below still
     has to be run on an idle machine).
   - Chunked reads fetch in batches of at most 64 MiB of stored bytes, one
-    `read_ranges` call each, so a remote read never holds more than that
-    undecoded; chunks already in the chunk cache are not fetched.
+    `read_ranges` call each, decoding each batch before fetching the next,
+    on every chunk-reading path (one helper,
+    `storage::for_each_extent_batch`); and no chunk fetches more than its
+    decoded size can need (`filters::stored_chunk_limit`), so a remote read
+    holds at most one batch undecoded even over a crafted chunk index;
+    chunks already in the chunk cache are not fetched.
   - The typed readers' zero-copy fast path became "read the contiguous
     bytes once": over a range storage a contiguous `read_f64` is one read,
     and a native contiguous selection reads only its runs.