Behavioral equivalence: source I/O traces + generated inputs

[Tokarzewski]

Context: Real-world metrics are compile-only — a file can compile and still be wrong. Most real code ships no tests.

Scope: (1) Instrument the SOURCE (run its own tests or generated inputs), capture input→output traces, assert the transpiled target reproduces them. (2) Property-based/fuzzed input generation over inferred signatures to surface edge-case divergence. Verify at the smallest runnable boundary (usually function); sub-function nodes get structural/type checks only.

Acceptance: a behavioral pass-rate (run + output match) reported alongside compile-rate for examples/samples/.

[Tokarzewski]

First increment landed — the behavioral-equivalence engine + a pass-rate metric.

New module src/transpilers/verify/behavioral.py:

• Source oracle + target replay. Generates inputs over a function's inferred signature, runs the source as the oracle, runs the target over the same inputs, and compares — at the smallest runnable boundary (the function). Inputs on which the source itself raises are dropped (only assert behavior the source defines).
• Property/fuzz inputs (generate_inputs): deterministic edge cases (0, ±1, empty, …) first, then seeded random fuzz; per-arg staggering so arg-order bugs are reachable.
• Type-aware comparison via a canonical-token protocol (ints exact, floats within tolerance, bools/None/list spellings normalized across languages).
• Runners: PythonRunner (toolchain-free oracle + Python target) and RustRunner (compiles a generated harness with rustc, scalar + Vec-of-scalar signatures; auto-detects by-reference params like & Vec<i64> so it matches emitted signatures instead of reporting false divergences). Undrivable signatures are reported unsupported (skipped), never a false fail.
• Repair-loop integration: make_behavioral_verifier returns a Verifier that turns a divergence into a run_mismatch RepairSignal, so Verification-driven repair loop (escalating tiers) #47's escalating loop can feed the diverging input + expected/actual to the LLM.

Metric (acceptance): scripts/behavioral_sweep.py reports behavioral pass-rate alongside compile-rate over a corpus, with an honest supported/unsupported split. On a demo corpus of annotated leaf functions (examples/behavioral/numeric.py), python→rust via the real pipeline: compile-rate 100%, behavioral pass-rate 6/6. (examples/samples/Python is mostly unannotated whole-program scripts — the sweep reports that as low drivable coverage rather than a misleading number.)

Tests: tests/test_behavioral.py (24) — Python↔Python always, Python→Rust gated on rustc. Full repair+verify+api suite: 78 passed.

Deferred (need toolchains not present here / larger scope): non-Python source oracles; compiled targets beyond Rust (C/Go/Zig/Mojo/Fortran) via their _fmt harnesses; sweep over a larger annotated corpus. The Runner protocol is the extension point. Leaving open for those.