perf(scan): fuse validate_brackets into NEON scanner

Eliminate the separate validate_brackets pass in the NEON scanner by
carrying a depth stack inline during emit. This mirrors the scalar
scanner's fused scan_and_validate approach.

Changes:
- Add emit_bits_validate() that validates brackets while emitting
- Add scan_tail_validate() for the scalar tail with inline validation
- Gate emit_bits, validate_brackets, scan_emit_resume with #[cfg] for
  AVX2-only (they remain used by the AVX2 scanner)

Profile on bench fixtures showed validate_brackets consuming ~30% of
scan time on structure-dense payloads (small_api.json). The fusion
eliminates this second pass.

Closes #25

Author: membphis

src/scan/mod.rs

@@ -80,6 +80,7 @@ pub(crate) fn find_escape_mask_with_carry(bs: u64, prev_carry: &mut u64) -> u64
 }
 
 /// Emit all set-bit positions in `mask` (relative to `base`) into `out`.
+#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
 #[inline(always)]
 pub(crate) fn emit_bits(mut mask: u64, base: u32, out: &mut Vec<u32>) {
     while mask != 0 {
@@ -99,6 +100,7 @@ pub(crate) fn emit_bits(mut mask: u64, base: u32, out: &mut Vec<u32>) {
 ///
 /// On the first mismatch, returns `Err(offset_in_buf)`. On unmatched
 /// openers at end of input, returns `Err(buf.len())`.
+#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
 pub(crate) fn validate_brackets(buf: &[u8], indices: &[u32]) -> Result<(), usize> {
     let mut stack: Vec<u8> = Vec::with_capacity(32);
     let mut in_string = false;

src/scan/neon.rs

@@ -142,6 +142,7 @@ unsafe fn scan_neon_impl(buf: &[u8], out: &mut Vec<u32>) -> Result<(), usize> {
     let mut i = 0usize;
     let mut bs_carry: u64 = 0;
     let mut in_string: u64 = 0;
+    let mut stack: Vec<u8> = Vec::with_capacity(32);
 
     while i + 64 <= buf.len() {
         let c0 = vld1q_u8(buf.as_ptr().add(i));
@@ -199,23 +200,119 @@ unsafe fn scan_neon_impl(buf: &[u8], out: &mut Vec<u32>) -> Result<(), usize> {
 
         let struct_mask = tag_mask64(t0, t1, t2, t3, TAG_STRUCTURAL);
         let final_mask = (struct_mask & !inside) | real_quote;
-        super::emit_bits(final_mask, i as u32, out);
+        emit_bits_validate(final_mask, i as u32, buf, out, &mut stack)?;
         i += 64;
     }
 
-    // Tail (<64 bytes): hand off to scalar emit, carrying in_string / bs_carry state.
+    // Tail (<64 bytes): hand off to scalar, carrying in_string / bs_carry / stack state.
     if i < buf.len() {
         let scalar_start = if in_string != 0 && bs_carry != 0 {
             i + 1
         } else {
             i
         };
-        super::scalar::scan_emit_resume(buf, scalar_start, in_string != 0, out)?;
+        scan_tail_validate(buf, scalar_start, in_string != 0, out, &mut stack)?;
     } else if in_string != 0 {
         return Err(buf.len());
     }
 
-    super::validate_brackets(buf, out)
+    if !stack.is_empty() {
+        return Err(buf.len());
+    }
+    Ok(())
+}
+
+/// Emit structural offsets and validate brackets inline.
+#[inline(always)]
+fn emit_bits_validate(
+    mut mask: u64,
+    base: u32,
+    buf: &[u8],
+    out: &mut Vec<u32>,
+    stack: &mut Vec<u8>,
+) -> Result<(), usize> {
+    while mask != 0 {
+        let tz = mask.trailing_zeros();
+        let pos = base + tz;
+        out.push(pos);
+        let b = buf[pos as usize];
+        match b {
+            b'{' | b'[' => stack.push(b),
+            b'}' => {
+                if stack.pop() != Some(b'{') {
+                    return Err(pos as usize);
+                }
+            }
+            b']' => {
+                if stack.pop() != Some(b'[') {
+                    return Err(pos as usize);
+                }
+            }
+            _ => {}
+        }
+        mask &= mask - 1;
+    }
+    Ok(())
+}
+
+/// Scalar tail with inline bracket validation, continuing from NEON state.
+fn scan_tail_validate(
+    buf: &[u8],
+    start: usize,
+    in_str_init: bool,
+    out: &mut Vec<u32>,
+    stack: &mut Vec<u8>,
+) -> Result<(), usize> {
+    let mut i = start;
+    let mut in_str = in_str_init;
+
+    while i < buf.len() {
+        let b = buf[i];
+
+        if in_str {
+            if b == b'\\' {
+                i += 2;
+                continue;
+            }
+            if b == b'"' {
+                in_str = false;
+                out.push(i as u32);
+            }
+            i += 1;
+            continue;
+        }
+
+        match b {
+            b'"' => {
+                in_str = true;
+                out.push(i as u32);
+            }
+            b'{' | b'[' => {
+                out.push(i as u32);
+                stack.push(b);
+            }
+            b'}' => {
+                out.push(i as u32);
+                if stack.pop() != Some(b'{') {
+                    return Err(i);
+                }
+            }
+            b']' => {
+                out.push(i as u32);
+                if stack.pop() != Some(b'[') {
+                    return Err(i);
+                }
+            }
+            b':' | b',' => out.push(i as u32),
+            _ => {}
+        }
+        i += 1;
+    }
+
+    if in_str {
+        return Err(buf.len());
+    }
+    Ok(())
 }
 
 #[cfg(test)]

src/scan/scalar.rs

@@ -45,6 +45,7 @@ pub(crate) fn scan_and_validate(buf: &[u8], out: &mut Vec<u32>) -> Result<(), us
 /// Used by `ScalarScanner::scan` (with start=0, in_str_init=false) and as
 /// the unaligned-tail handler by `Avx2Scanner::scan` (with the carried
 /// in-string state from the last AVX2 chunk).
+#[cfg(all(target_arch = "x86_64", feature = "avx2"))]
 pub(crate) fn scan_emit_resume(
     buf: &[u8],
     start: usize,