test: add scan1ddebug tool + curved-bottle EAN fixture

Diagnostic example that runs scan1d on a PNG, prints each recovered candidate's
module count/confidence, and (given the known payload) its best-alignment
Hamming distance to the true encoded pattern plus the EAN decode verdict.

testdata/real_scene_ean_curved.png is the exact located box (256x96) from a real
capture of an EAN-13 on a curved bottle: small (~2.4px/module), blurred, low
contrast (brown-on-gold). scan1d recovers the pattern to within Hamming 4 of the
truth but fails to decode — the errors sit in the thin single-module guard
features that blur merges, and different scanlines corrupt different modules.
Pins the real-world 1D decode-robustness gap for the edge-ratio fix.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MagicalTux

Cargo.toml

@@ -54,3 +54,7 @@ required-features = ["cli"]
 [[example]]
 name = "locdebug"
 required-features = ["cli"]
+
+[[example]]
+name = "scan1ddebug"
+required-features = ["cli"]

examples/scan1ddebug.rs

@@ -0,0 +1,76 @@
+// Diagnostic: what does scan1d recover on a real 1D photo, and why does EAN reject it?
+use anyd::codes::ean::EanDecoder;
+use anyd::output::Encoding;
+use anyd::scan1d::{ScanOptions, scan_lines};
+use anyd::traits::Decode;
+
+fn main() {
+    let path = std::env::args().nth(1).expect("usage: scan1ddebug <png>");
+    let rgba = oxideav_png::decode_png_to_rgba(&std::fs::read(&path).unwrap()).unwrap();
+    let (w, h) = (rgba.width as usize, rgba.height as usize);
+    let luma: Vec<u8> = rgba
+        .data
+        .chunks_exact(4)
+        .map(|p| ((p[0] as u32 * 299 + p[1] as u32 * 587 + p[2] as u32 * 114) / 1000) as u8)
+        .collect();
+    let frame = anyd::GrayFrame::new(&luma, w, h).unwrap();
+
+    // Reference: encode the known payload to compare recovered patterns against.
+    let reference: Option<Vec<bool>> = std::env::args().nth(2).and_then(|digits| {
+        use anyd::codes::ean::EanEncoder;
+        use anyd::traits::Encode;
+        let enc = EanEncoder::new();
+        let sym = enc.build_ean13(&digits).ok()?;
+        match enc.encode(&sym).ok()? {
+            Encoding::Linear(p) => Some(p.modules),
+            _ => None,
+        }
+    });
+    if let Some(r) = &reference {
+        println!("reference pattern: {} modules", r.len());
+    }
+    let as_str = |m: &[bool]| {
+        m.iter()
+            .map(|&b| if b { '#' } else { '.' })
+            .collect::<String>()
+    };
+
+    let opts = ScanOptions::default();
+    let cands = scan_lines(&frame, &opts);
+    println!("frame {w}x{h}: {} scan1d candidates", cands.len());
+    let dec = EanDecoder::new();
+    for (i, c) in cands.iter().enumerate() {
+        let mods = c.pattern.modules.len();
+        let quiet = c.pattern.quiet_zone;
+        let res = dec.decode(&Encoding::Linear(c.pattern.clone()));
+        let verdict = match res {
+            Ok(s) => format!("OK -> {:?}", s.text()),
+            Err(e) => format!("ERR {e}"),
+        };
+        // Best-alignment Hamming distance vs reference (slide the shorter over the longer).
+        let hd = reference.as_ref().map(|r| {
+            let (a, b) = (&c.pattern.modules, r);
+            let (short, long) = if a.len() <= b.len() { (a, b) } else { (b, a) };
+            let mut best = short.len();
+            for off in 0..=(long.len() - short.len()) {
+                let d = short
+                    .iter()
+                    .zip(&long[off..])
+                    .filter(|(x, y)| x != y)
+                    .count();
+                best = best.min(d);
+            }
+            best
+        });
+        println!(
+            "  [{i}] conf={:.3} modules={mods} quiet={quiet} hamming={hd:?} :: {verdict}",
+            c.confidence
+        );
+        if reference.is_some() && (93..=97).contains(&mods) {
+            println!("       {}", as_str(&c.pattern.modules));
+        }
+    }
+    if let Some(r) = &reference {
+        println!("  REF  {}", as_str(r));
+    }
+}