Merge Fat Teddy (Task B) multi-pattern OR

Brings in `MultiNeedleMatcher` + `dfa/fat_teddy.rs` (8-bucket Fat
Teddy with greedy bucket-packing, AVX2 + scalar, per-bucket
`FoldedContainsDfa::matches` verifier) plus 12 new unit/property
tests and 6 multi-needle OR benches.

Conflicts resolved:
- `mod.rs`: kept HEAD's empirically-tuned ShiftOr gate (no
  escape-only eligible AND no first-byte present in any symbol AND
  no SSA), plus Task A's `first_byte_present_in_any_symbol`
  helper; appended Fat Teddy's `MultiNeedleMatcher` section
  unchanged.
- `tests.rs`: HEAD's test bodies covering the richer ShiftOr
  routing predicates; appended Fat Teddy's `MultiNeedleMatcher`
  test section (12 new tests).
- `benches/fsst_like.rs`: appended Fat Teddy's six
  `fsst_contains_or_*` benches (3-, 8-, 16-needle Fat Teddy vs
  N-pass baselines on the ClickBench URL corpus).

Deferred TODOs preserved from the subagent's commit:
- Cross-bucket FDR for ESCAPE_CODE-anchored needles (falls back
  to N-pass).
- AVX-512 and NEON variants of `fat_teddy_pass_*`.
- Planner integration (Task C, separate merge).

196 tests pass with `_test-harness`. `cargo +nightly fmt --all`
clean.

Author: Claude Agent

encodings/fsst/benches/fsst_like.rs

@@ -224,3 +224,125 @@ fn fsst_contains_short_qq_cb(bencher: Bencher) {
 fn fsst_contains_short_xyzz_rare(bencher: Bencher) {
     bench_like(bencher, &FSST_RARE_MATCH, "%xyzz%");
 }
+
+// ---------------------------------------------------------------------------
+// Fat Teddy / multi-needle OR benches
+//
+// Each `fsst_contains_or_<n>_<dataset>` bench runs `MultiNeedleMatcher`
+// (Fat Teddy single pass) on a small needle list, while the
+// `fsst_contains_or_<n>_<dataset>_npass` baseline runs the same needles
+// as N separate single-pattern `FsstMatcher` scans and bitwise-ORs the
+// results. The Fat Teddy variant should be ≥ 1.5× faster than the
+// N-pass baseline for n ≥ 4.
+// ---------------------------------------------------------------------------
+
+/// Run `MultiNeedleMatcher::scan_or_to_bitbuf` on `fsst` for the given
+/// needle list, returning the OR bit-buffer.
+fn fat_teddy_or(fsst: &FSSTArray, patterns: &[&str]) -> vortex_buffer::BitBuffer {
+    #[expect(deprecated)]
+    use vortex_array::ToCanonical;
+    use vortex_array::arrays::varbin::VarBinArrayExt;
+    use vortex_array::match_each_integer_ptype;
+    use vortex_fsst::FSSTArrayExt;
+    use vortex_fsst::dfa::MultiNeedleMatcher;
+
+    let symbols = fsst.symbols();
+    let symbol_lengths = fsst.symbol_lengths();
+    let codes = fsst.codes();
+    #[expect(deprecated)]
+    let offsets = codes.offsets().to_primitive();
+    let all_bytes = codes.bytes();
+    let all_bytes = all_bytes.as_slice();
+    let n = codes.len();
+    let pattern_bytes: Vec<&[u8]> = patterns.iter().map(|s| s.as_bytes()).collect();
+    let matcher = MultiNeedleMatcher::try_new_multi(
+        symbols.as_slice(),
+        symbol_lengths.as_slice(),
+        &pattern_bytes,
+        false,
+    )
+    .unwrap()
+    .unwrap();
+    match_each_integer_ptype!(offsets.ptype(), |T| {
+        let off = offsets.as_slice::<T>();
+        matcher.scan_or_to_bitbuf(n, off, all_bytes, false)
+    })
+}
+
+/// Run N separate single-pattern `FsstMatcher` scans and OR-merge them.
+fn npass_or(fsst: &FSSTArray, patterns: &[&str]) -> vortex_buffer::BitBuffer {
+    #[expect(deprecated)]
+    use vortex_array::ToCanonical;
+    use vortex_array::arrays::varbin::VarBinArrayExt;
+    use vortex_array::match_each_integer_ptype;
+    use vortex_fsst::FSSTArrayExt;
+    use vortex_fsst::dfa::FsstMatcher;
+
+    let symbols = fsst.symbols();
+    let symbol_lengths = fsst.symbol_lengths();
+    let codes = fsst.codes();
+    #[expect(deprecated)]
+    let offsets = codes.offsets().to_primitive();
+    let all_bytes = codes.bytes();
+    let all_bytes = all_bytes.as_slice();
+    let n = codes.len();
+    let mut acc: Option<vortex_buffer::BitBuffer> = None;
+    for p in patterns {
+        let m = FsstMatcher::try_new_with(
+            symbols.as_slice(),
+            symbol_lengths.as_slice(),
+            p.as_bytes(),
+            false,
+        )
+        .unwrap()
+        .unwrap();
+        let r = match_each_integer_ptype!(offsets.ptype(), |T| {
+            let off = offsets.as_slice::<T>();
+            m.scan_to_bitbuf(n, off, all_bytes, false)
+        });
+        acc = Some(match acc {
+            Some(prev) => &prev | &r,
+            None => r,
+        });
+    }
+    acc.unwrap()
+}
+
+static NEEDLES_OR_3_URLS: &[&str] = &["%google%", "%yandex%", "%bing%"];
+static NEEDLES_OR_8_URLS: &[&str] = &[
+    "%google%", "%yandex%", "%bing%", "%duck%", "%wiki%", "%news%", "%blog%", "%shop%",
+];
+static NEEDLES_OR_16_URLS: &[&str] = &[
+    "%google%", "%yandex%", "%bing%", "%duck%", "%wiki%", "%news%", "%blog%", "%shop%", "%com%",
+    "%org%", "%net%", "%info%", "%http%", "%https%", "%www%", "%api%",
+];
+
+#[divan::bench]
+fn fsst_contains_or_3_urls(bencher: Bencher) {
+    bencher.bench(|| fat_teddy_or(&FSST_CB_URLS, NEEDLES_OR_3_URLS));
+}
+
+#[divan::bench]
+fn fsst_contains_or_3_urls_npass(bencher: Bencher) {
+    bencher.bench(|| npass_or(&FSST_CB_URLS, NEEDLES_OR_3_URLS));
+}
+
+#[divan::bench]
+fn fsst_contains_or_8_urls(bencher: Bencher) {
+    bencher.bench(|| fat_teddy_or(&FSST_CB_URLS, NEEDLES_OR_8_URLS));
+}
+
+#[divan::bench]
+fn fsst_contains_or_8_urls_npass(bencher: Bencher) {
+    bencher.bench(|| npass_or(&FSST_CB_URLS, NEEDLES_OR_8_URLS));
+}
+
+#[divan::bench]
+fn fsst_contains_or_16_urls(bencher: Bencher) {
+    bencher.bench(|| fat_teddy_or(&FSST_CB_URLS, NEEDLES_OR_16_URLS));
+}
+
+#[divan::bench]
+fn fsst_contains_or_16_urls_npass(bencher: Bencher) {
+    bencher.bench(|| npass_or(&FSST_CB_URLS, NEEDLES_OR_16_URLS));
+}