Add batch mode for JSONL function runs

[dnagoda]

Refs shop/issues-checkout#13420

Why

Checkout Blocks parity testing needs to replay large production datasets efficiently and faithfully. Migration validation often requires rerunning hundreds of thousands of function inputs, and invoking function-runner once per row spends most of the time on repeated process startup plus Wasmtime engine/module setup.

This branch adds a JSONL batch execution mode so callers like function-rerunner can stream many inputs through one runner process while reusing the loaded function module.

The branch also includes a JSON input fidelity fix discovered while using batch reruns for Checkout Blocks discount parity: function-runner was sorting JSON object keys during parse/reserialize. That changed object-order-sensitive JS fallback behavior and produced false localized-message mismatches.

What

Batch execution

• Adds --batch mode.
• Reads newline-delimited JSON inputs from --input or piped stdin.
• Emits one compact JSON result per input line to stdout.
• Reuses the Wasmtime engine and loaded module across all inputs.
• Adds --batch-continue-on-error for best-effort processing when individual lines fail.
• Keeps schema/query scale-factor analysis available per input when schema/query paths are provided.
• Disables profiling in batch mode to avoid per-row profile artifacts and overhead.

JSON input fidelity

• Enables serde_json's preserve_order feature so JSON object key order survives input normalization.
• Adds regression coverage for nested JSON object key-order preservation.
• Updates Cargo.lock for the indexmap dependency required by serde_json/preserve_order.

Testing / parity

• cargo test json_input_preserves_object_key_order_in_raw_bytes
• cargo build --release
• cargo test

Checkout Blocks parity verification with the rebuilt local runner:

• Retested the 17 known discount localized-message mismatch rows through function-rerunner.
• Confirmed full target semantic parity after the runner fix:
  • discount-order: 250,003 / 250,003 semantic matches
  • discount-shipping: 250,002 / 250,002 semantic matches

Risks

• Batch mode introduces a streaming output contract: consumers must parse one compact JSON object per stdout line.
• --batch-continue-on-error returns per-line error JSON for failures; consumers should handle success and error rows explicitly.
• Preserving JSON key order changes local runner behavior from sorted-map normalization to input-order-preserving normalization. This is intentional because it better matches production input semantics.
• serde_json/preserve_order adds an indexmap dependency.

[dnagoda]

@davejcameron I created this draft PR to at least start the conversation about merging these changes into main. Is there any reason not to pursue that?

[jeffcharles]

It makes sense to me to add a mode where we batch a bunch of inputs and write a series of outputs.

The code changes seem a bit messier though. I think we could update the Provider struct to store Module instead of bytes to reduce the number of new abstractions (like CompiledProvider) and methods. Might be worth having the LLM take another pass at generating the code.

You can also open a separate PR to add preserve_order to keep the size of the diff more manageable for reviewing.

[dnagoda]

@jeffcharles Yep, code definitely needs to be cleaned up and split into distinct changes. It's a bit of a dumping ground at the moment.