perf(j2k-native): packed-column Tier-1 passes for BYPASS code-blocks #311

Now that Persimmon is on 0.13.1, I compared it with Kakadu 8.6.2 again (Persimmon's adapter built natively for macOS arm64, every 1024 px tile at every scale, JPEG output). On the 18000×12000 images j2k is now within 3–12% of Kakadu, at about the same memory, which is great. The remaining gap is on the 6000×4000 archival image. That's the kind of untiled, Kakadu-encoded JP2 our repository holds, so it's what Persimmon mostly serves. There Kakadu was 1.5–1.6 times faster.

Why. That image is classic, with 7 layers, 64×64 code-blocks, RPCL and Cmodes=BYPASS. On a serial 1024² region, Tier-1 is about 84% of the decode (66–68 ms of about 79 ms). A sample profile shows the whole of Tier-1 on the per-coefficient passes, arithmetic.rs and bypass.rs, arithmetic passes included. reset_for_job only uses the packed columns when every segment is arithmetic and the style is single_codeword_segment(), because packed and per-coefficient state can't be mixed within a block. So any selective bypass, or termination on each pass, keeps a block off the passes #303 sped up.

Prototype. I tried giving those blocks packed passes, on a branch off main:

• Eligibility. packed_columns = !vertically_causal_context. Bypass, termination on each pass, context resets and segmentation symbols all take the packed columns.
• Raw passes. flag_passes.rs gains significance_propagation_pass_raw, magnitude_refinement_pass_raw and cleanup_pass_raw. They make the decisions of the packed arithmetic passes in the same order, reading raw bits: no contexts, and the raw sign bit is the sign, with no XOR. The arithmetic passes are untouched.
• Raw reader. A RawBits reader buffers up to 64 de-stuffed bits. It skips the top bit of the byte after a 0xFF and returns ones once the segment is exhausted, as BypassDecoder does. Before a 0xFF whose stuffing it can't vouch for (the stuffed bit is one, or the data ends), it stops buffering and hands the rest of the segment to a BypassDecoder. So strict and lenient decodes of malformed data come out exactly as now.
• Dispatch. Both segment loops in schedule.rs run raw segments on the packed raw passes when the block uses packed columns, and reset_for_next_bitplane skips its per-coefficient bypass bookkeeping for packed blocks.
• Tests. A test-only switch, FORCE_PER_COEFFICIENT, keeps the per-coefficient passes testable, and the four state tests that check their internals set it. A new parity test encodes random code-blocks in all 16 non-causal style combinations, 8 sizes, 4 sub-band types and 1 to 16 bitplanes, about a quarter of them with raw segments. It decodes each with both sets of passes, strict and lenient, and also 24 corrupt copies of each (bit flips, bytes set to 0xFF, truncation). Samples and errors match exactly. With a deliberately flipped raw sign bit, it fails at once.

Results. Serial component-plane region decodes, against main, medians of 11 runs. Output hashes and peak heap are identical.

In Persimmon's tile benchmark on the archival image, with Kakadu, 0.13.1 and the prototype run alternately:

That takes the gap from about 1.5× to about 1.3×. The gain is larger than the raw passes alone would explain, because moving the block onto packed columns speeds up its arithmetic passes too. After the change, the profile is about a third cleanup, a fifth arithmetic significance propagation and a sixth raw significance propagation, with the IDWT and output about 15%. The raw significance pass now costs about the same per decision as the arithmetic one: the cost is the column scanning and significance updates, not the bit reads.

Questions.

1. This is right next to the code you just changed in perf(j2k-native): faster CPU classic Tier-1 decoding #303. Would you like a PR from me, or would you rather take it from here? I'm happy either way, and can push the branch for you to look at.
2. Generalizing the arithmetic Scan over a symbol source might avoid the duplicated raw passes, but I kept your arithmetic passes byte for byte so as not to disturb what perf(j2k-native): faster CPU classic Tier-1 decoding #303 tuned. Do you prefer one or the other?
3. Termination on each pass, context resets and segmentation symbols now take the packed columns too. The parity test covers all those combinations, but tell me if there's a reason they were kept off.
4. all_segments_arithmetic on reset_for_job is now unused. I'd remove it in a PR.