[wip] fix arithmetic divergences between interpreter, const folding and JIT

[aleksisch]

Divergences and codegen bugs found by fuzzing, where one execution tier disagreed with another or where AOT emitted code that did not compile. All reachable from plain .das source with no macros.

Arithmetic: interpreter vs const folding vs JIT

• abs(-0.0) returned -0.0 — SimPolicy_MathTT::Abs is a >= 0 ? a : -a, and v_abs on x86 clang is max(-a, a), where MAXPS hands back its second operand for equal inputs. The JIT emits fabs and was already right, so the interpreter disagreed with the JIT and with itself across targets. 1.0 / abs(-0.0) was -inf.
• INT_MIN / -1 was poison under -jit — the interpreter throws division overflow and answers 0 for INT_MIN % -1; the JIT emitted a raw sdiv/srem. Bumps LLVM_JIT_CODEGEN_VERSION, or cached DLLs keep serving the unguarded code.
• half(x) flushed every subnormal to zero — das_float_to_float16's subnormal branch double-counted the 23->10 mantissa reduction. For the smallest inputs the shift reached 38, which is UB on uint32_t, and produced -nan. Hits any x under 6.104e-5.
• floatN(s) * k collapsed to a scalar multiply — with both operands scalar after the ctor is peeled, the fold dropped the vector while the expression kept its floatN type. The interpreter read whatever the unwritten lanes held; the LLVM backends rejected the call outright with Call parameter type does not match function signature!, then panicked in llvm_jit_run with Failed to get IR.

AOT: control flow out of try / recover (#3858)

The try and recover bodies are emitted as C++ lambdas passed to das_try_recover, so an exit targeting anything outside them stayed inside the lambda:

• break / continue targeting an enclosing loop landed outside that loop and the generated C++ did not compile — 'break' statement not in loop or switch statement;
• a return from the function only left the lambda, so execution fell through to whatever followed the try. No diagnostic, and the AOT build silently returned a different value than the interpreter. tests/language/div_by_zero.das already had that shape.

The emitter now tracks loop/try nesting. An exit whose nearest lambda boundary is a try sets a control flag and returns from the lambda; the dispatch emitted right after das_try_recover turns the flag back into the real exit. A return parks its value in a slot typed by the function result first — a pointer, for a function returning a reference. The dispatch is itself translated the same way, so nested try/recover chains the exit outwards one level at a time.

Compile time: unbounded compile-time evaluation (#3858)

RunFolding evaluates a pure call over constant arguments by interpreting the real function body, with nothing watching how long that takes. A callee whose loop runs very long, or does not terminate at all, hangs the compiler: i = i - 1 in place of i = i + 1 in tests/language/optimization_cse.das takes compilation from 0.27s to 55s, and i = i * 1 in tests/language/optimization_dead_stores.das never finishes.

Each evaluated call now gets a loop-iteration budget, max_run_iterations (default 1000000; 0 or less removes the limit). Loop bodies simulated for the folding context get one extra node which spends the budget and throws once it runs out; the call is then left unfolded, exactly as for any other compile-time evaluation that fails. Loop bodies built for the real context never carry the node, so ordinary execution is untouched.

Also

• tests/aot: the default-ctor fixture declared no module and was listed nowhere in the AOT build, so the struct's generated default constructor had no translation unit and the nightly test_aot link failed with error[50101]. Names the module and adds AOT_TESTS_MODULE_FILES so tests/aot helper modules get a DAS_AOT_LIB TU.

Verification

• tests/: 12322 tests, 0 failed, 0 errors (baseline at the arithmetic commits alone: 12300 — the delta is the new tests).
• test_aot_subset (real AOT stubs, fail_on_no_aot): 1568 tests, 0 failed. The new try/recover control-flow tests run as AOT-compiled code there.
• Negative controls: with the old emitter, return_in_try() compiles to a fallthrough returning -1 where the test expects 10; raising max_run_iterations makes the over-budget fold test fail, and setting it to 0 hangs the spin repro again.

Marked WIP: not yet run through full preflight.