comptime VM: host wiring, full corpus parity, build flag, Phase 3 seed

Phase 1.final of the flat-memory comptime VM — wire the host through it,
reach corpus parity, and gate it behind a build flag — plus the first
Phase 3 (compiler-API) step. Default OFF; legacy interpreter unchanged.

Host wiring + hardening:
- Machine accessors return error.OutOfBounds (no debug panic) on bad
  addresses; Frame.get/set bounds-check and bail (no panic) on a malformed
  operand ref (e.g. a ret Ref.none from an unresolved name).
- tryEval routed at both comptime call sites in emit_llvm — the const-init
  fold and the #run side-effect path — with per-eval legacy fallback;
  yields .void_val for void/noreturn entries. Both sites sx_trace_clear()
  before the legacy fallback so a partial VM run that pushed trace frames
  doesn't double-push on re-run.

VM coverage (all corpus const-inits except the inline-asm global):
- Implicit context materialized from the __sx_default_context global; the
  full allocator protocol runs on the VM (context.allocator.alloc ->
  call_indirect -> CAllocator thunk -> libc_malloc -> native flat malloc).
- Native libc memory builtins (malloc/calloc/free/memcpy/memmove/memset)
  on flat memory; f32 stored/loaded as the 4-byte single; signed sub-64-bit
  loads sign-extended; global_get (lazy + memoized); func_ref/call_indirect
  (func-ref encoded fid+1, 0 reserved for null); string/slice fat-pointer
  field access; is_comptime; the failable/error cluster (error_set tuples,
  trace_frame + native sx_trace_push/clear -> raise/catch/or + return traces).

Build flag + Phase 3 seed:
- -Dcomptime-flat (build_opts module) OR SX_COMPTIME_FLAT env enables the VM;
  zig build test -Dcomptime-flat runs the full corpus on the VM (688/0).
- intern/text_of serviced natively on flat memory via Vm.callCompilerFn
  (compiler_welded boundary) — the seed the rest of the compiler-API grows on.

Parity 688/688 gate ON and OFF. Unit tests added throughout. The
lowering-time #insert wiring was explored and reverted (lowering-time IR can
be malformed; full malformed-IR hardening is a prerequisite, deferred).

build.zig

@@ -234,6 +234,20 @@ pub fn build(b: *std.Build) void {
     corpus_opts.addOption([]const u8, "name", name_filter);
     mod.addOptions("corpus_paths", corpus_opts);
 
+    // `zig build [test] -Dcomptime-flat` defaults comptime evaluation to the
+    // flat-memory VM (`src/ir/comptime_vm.zig`), with the legacy tagged interpreter
+    // as the per-eval fallback — the "swap behind a build flag" step of
+    // `current/PLAN-COMPILER-VM.md`. Default OFF (legacy). The `SX_COMPTIME_FLAT`
+    // env var enables it too (either turns it on); read in `emit_llvm.zig::init`.
+    const comptime_flat = b.option(
+        bool,
+        "comptime-flat",
+        "Default comptime evaluation to the flat-memory VM (legacy interp as fallback)",
+    ) orelse false;
+    const build_opts = b.addOptions();
+    build_opts.addOption(bool, "comptime_flat", comptime_flat);
+    mod.addOptions("build_opts", build_opts);
+
     const mod_tests = b.addTest(.{
         .root_module = mod,
     });