pxf: TableReader streaming + scan / BindRow

[trendvidia]

Summary

Companion to protowire-go v0.74 (pxf.TableReader streaming) and v0.75 (TableReader.scan + pxf.BindRow). Reads rows from an InputStream one at a time with working-set memory bounded by the size of the largest single row — the shape consumers need for CSV-replacement datasets that don't fit in memory.

```java
try (var tr = new TableReader(in)) {
while (true) {
var b = AllTypes.newBuilder();
if (!tr.scan(b)) break;
process(b.build());
}
}
```

Cell-state semantics match BindRow: a null cell leaves the field absent (pxf.default applied, pxf.required errors), an Ast.NullVal cell clears wrappers / optional / oneof per §3.9, any other value sets the field. WKT timestamps + durations, enum-by-name, proto3 wrappers all bind correctly because BindRow re-uses the existing unmarshal pipeline (format-and-reparse).

API additions

Symbol	Purpose
`TableReader(InputStream)`	Reads through leading directives + header, returns reader positioned at the first row
`(*TableReader).type() / columns() / directives()`	Header accessors
`(*TableReader).next()`	Reads next row; returns `null` at EOF. Errors are sticky
`(*TableReader).scan(Message.Builder)`	Reads next row + binds to msg via BindRow; returns false at EOF
`(*TableReader).tail()`	InputStream yielding buffered + remaining bytes; chain for multi-table docs
`BindRow.bindRow(Message.Builder, List, Ast.TableRow)`	Standalone helper

Implementation

• Row-boundary scanner. Byte-level walker with string / bytes-literal / line-comment / block-comment awareness — embedded parens / ) inside literals don't trip the scan. Mirrors protowire-go's findNextRow in table_stream.go.
• Header reuses Parser.parse(). Buffered header prefix (up through the column-list )) is parsed by the existing AST parser, so the standalone constraint, dotted-column rejection, and arity enforcement all flow through unchanged.
• Per-row decode reuses Parser.parseTableRow. New package-private static helper Parser.parseTableRow(byte[], int) lets TableReader decode each row's byte slice without re-running the full document grammar.
• BindRow strategy. Render each non-null cell back to PXF text (<column> = <value>\n), concat as synthetic body, run UnmarshalOptions.withSkipValidate(true).unmarshal. Reuses every existing decoder branch (WKTs, wrappers, enums, defaults, required, oneof) for zero new switch arms. Same trade protowire-go made.
• Header byte budget caps at 64 KiB — fail-fast against a TableReader pointed at a giant body-only document with no @table ever.

Tradeoffs

• Errors are sticky. Once next() or scan throws, subsequent calls rethrow the same exception. Matches the Go port's contract.
• tail() semantics. Must only be called after next() returns null. Calling earlier returns bytes the current reader still intends to consume, which desynchronizes the next reader.
• TableReader does NOT implement AutoCloseable. The underlying InputStream is the caller's responsibility; closing the reader would close `src` and prevent tail() chaining. Documented in javadoc.
• 24 tests, lots of byte-precise coverage. The byte-at-a-time ChunkedStream reader is adversarial for any buffer-boundary bug; protowire-go's equivalent caught real issues there.

Stacking

Fourth of five Java port PRs:

1. ✅ pxf: parser-side support for v0.72/v0.73 grammar features #35 — parser-side support for v0.72/v0.73 grammar
2. ✅ pxf: schema reserved-name check (draft §3.13) #36 — schema reserved-name check
3. ✅ pxf: Result.directives() / Result.tables() accessors #37 — Result accessors
4. This PR — TableReader streaming + scan / BindRow
5. Next — release-cut + JetBrains jar refresh

Test plan

• `./gradlew :pxf:test` — all green (existing + 24 new `TableReaderTest`)
• Equivalence: streaming and materializing paths produce identical cell type/value sequences for the same input
• Byte-at-a-time `InputStream` works (`ChunkedStream` adversarial test)
• Multi-table via `tail()` recovers correctly
• `scan` works for all 9 cell value variants via WKT + wrapper + enum binding