feat: end-to-end streaming pack parser

[ivarvong]

What

Replaces the buffered pack-ingestion pipeline with a fully streaming one. The root cause was pack_binary + object_list living simultaneously in the heap — 2–3× the pack size, enough to OOM on large repos (esp-idf, linux, the adafruit CircuitPython bundle).

Memory model after this PR

Phase	Before	After
HTTP response	Full body in binary	One pkt-line at a time
Pack bytes	Full binary in heap	One chunk (~4 KB)
Object inflate	Full compressed buffer	Zlib port open across ingest/2 calls
Object storage	IO.iodata_to_binary + zlib.compress	Streaming deflate direct to store
Peak (opencode, 135 MB pack)	~300–400 MB	~store size only

Changes

Phase 1 — HTTP streaming transport

• PktLine.Decoder: incremental decoder for arbitrary network chunks
• HTTP.do_fetch / do_ls_refs: Req into: streaming callback feeds each chunk through the decoder and a fetch state machine; no response body is ever accumulated

Phase 2 — Pack.StreamParser

• Forward-only per-object decode; zlib port kept open across ingest/2 calls (Phase 3)
• Adler32 computed incrementally — locate_boundary never calls IO.iodata_to_binary
• OFS/REF delta resolution through the object store; offset_to_sha and sha_to_depth maps
• Key bug fixed: parse_next was discarding state2 (current + write_handle) on :need_more, causing O(n²) re-processing of the entire buffer on every new byte for large objects
• Feed cap: inflate_upper_bound(expected_size) bytes per do_inflate call

Phase 3+ — Streaming object-store writes

• New ObjectStore protocol callbacks: open_write/3, write_chunk/3, close_write/2, cancel_write/2
• Memory store: streaming deflate port; raw content never coexists with compressed form
• Disk store: temp file + streaming deflate + atomic rename
• Promisor: delegates to inner Memory cache
• Non-delta objects (blob/tag) use streaming writes; commits/trees go through the traditional path so their content lands in raw_cache for fast delta resolution

Phase 4 — Adversarial hardening

• max_object_bytes, max_inflate_ratio (zip-bomb defence), max_delta_depth, max_objects, deadline
• All enforced per-object during streaming parse, not as a post-parse check

Wiring

• HTTP.do_fetch, exgit.ex fetch_into, FS.prefetch_blobs, FS.do_fetch_commit_and_root_tree: all pass object_store: so every fetch path uses the streaming parser

Bug fix

• Tree.decode: removed .gitmodules from reserved names — it is a legitimate file in any repo using submodules; the URL-injection concern only applies if we process submodule config, which we do not. This was crashing prefetch on adafruit/Adafruit_CircuitPython_Bundle.

grep optimisation

• compile_grep_pattern: case-sensitive literals (no PCRE metacharacters) compile to {:literal, needle}
• scan_once/2: routes literals through :binary.matches (Boyer-Moore-Horspool) — 9.5× faster per-blob scan; adafruit bundle greps from N/A to 2 ms, opencode literals from ~200 ms to ~130 ms

Tests added

• Pack.StreamParserTest — correctness, chunked, byte-at-a-time, memory bound (18 tests)
• Pack.StreamParserAdversarialTest — zip bomb, deep delta chain, oversized, malformed, checksum, OFS-before-pack (17 tests + 1 property)
• Pack.StreamParserStreamingWriteTest — Memory/Disk streaming write correctness (9 tests)
• PktLine.DecoderTest — incremental decode parity (11 tests)
• HTTP streaming tests — 5000-packet reassembly, channel-3 abort, memory regression guard (3 tests)

626 tests, 0 failures.

Not in this PR

• FS.prefetch warm option: decompressing blobs into repo.blob_cache during prefetch so repeated greps avoid the 140 ms zlib.uncompress tax. The design is agreed (state on the struct, caller opts in); left for a follow-up.