test(matching): zsync adversarial - shifted-insertion + sparse-match (#2079 #2080)

[oferchen]

Summary

Combine the two zsync-prefilter adversarial regression gates the
optimisation tracker (project_zsync_optimizations.md) calls out for
the rolling-hash + bithash + MatchIndex pipeline that landed earlier in
the v0.6 cycle.

#2079 shifted-insertion

Extends crates/matching/tests/shifted_insertion_fixture.rs with
shifted_insertion_1mib_basis_matches_span_the_shift (+234 LoC):

• 1 MiB basis built from a deterministic xorshift64* PRNG.
• Parameterised (N, M) fixture vector covering 7 cells: head-aligned
  single block, mid-aligned single + multi-block, near-tail aligned,
  mid sub-block (1 byte, 7 bytes), and a quarter-position
  multi-block-with-tail unaligned insert.
• For each cell: insert N filler bytes (high-bit-set xorshift stream)
  at offset M, generate the delta, and assert (a) the script's total
  byte count, (b) literal_bytes covers at least N, (c) round-trip
  reconstruction is byte-identical, and (d) the COPY tokens reference
  basis blocks both before and after the insertion point with
  at most one boundary block lost.

This guards the property that any future prefilter (bithash, compact
keys, seq-match) cannot silently lose matches shifted by N bytes
against an aligned basis.

#2080 sparse-match

Adds crates/matching/src/index/sparse_match_tests.rs (new, +312 LoC),
registered from mod.rs. The test lives inside the index module
so it can read the otherwise private bithash and tag_table fields
without enlarging the public API.

• 100 MiB basis built from a deterministic xorshift64* PRNG.
• 100 MiB target: independent xorshift stream with the MSB forced,
  except a single 4 KiB region taken verbatim from the basis at offset
  32 MiB and replanted at target offset 64 MiB.
• Drives the rolling window across the full target buffer asserting:
  1. Exactly four block-aligned hits (4 KiB / 1024-byte block_len),
     referencing consecutive basis blocks starting at the planted
     offset / block_len, in order.
  2. Bithash rejection rate over the non-planted region is at least
     70 %. The design-note theoretical bound is 7/8 (87.5 %); the
     observed value at 100 MiB / 1 KiB blocks is ~78 % because the
     tag-table fast path saturates at this scale and clustering on
     the upper sum2 bits pulls the rejection rate below the uniform
     bound. The 70 % floor catches a regression below the "most
     probes are rejected" gate the project memory cites.

The 100 MiB test is marked #[ignore] (the existing fixture marks
16 MiB tests the same way) so the default cargo nextest matrix stays
fast. Stress runs invoke it via:

cargo nextest run --release -p matching --all-features \
  --run-ignored only -E 'test(sparse_match_100mib_single_overlap)'

Locally the test passes in 90 s wall clock with the actual rejection
rate at 0.786.

Two cheap sanity tests (basis_builder_is_deterministic,
target_non_planted_bytes_have_msb_set) run as part of the default
matrix and pin the fixture builder invariants on a 1 MiB prefix.

Files

• crates/matching/tests/shifted_insertion_fixture.rs (+234)
• crates/matching/src/index/sparse_match_tests.rs (new, +312)
• crates/matching/src/index/mod.rs (+2, register the new cfg(test)
  submodule)

Test plan

• cargo fmt --all -- --check clean
• cargo clippy -p matching --all-targets --all-features --no-deps -- -D warnings clean
• cargo nextest run -p matching --all-features - 318 passed, 3 skipped (the existing 16 MiB ignored cases plus the new 100 MiB ignored case)
• cargo nextest run --release -p matching --run-ignored only -E 'test(sparse_match_100mib_single_overlap)' - passes locally in 90 s, bithash rejection rate observed 0.786
• cargo nextest run -p matching -E 'test(shifted_insertion_1mib)' - new 1 MiB shifted-insertion case passes in 0.3 s