P5.5: migrate the 35 BuildOptions accessors off #compiler to VM-native abi(.compiler)

`BuildOptions :: struct #compiler { ...35 methods... }` becomes
`BuildOptions :: struct { }` (an opaque null-sentinel handle) plus 35 free
`ufcs (self: BuildOptions, …) abi(.compiler)` decls in build.sx, each serviced
by a new `comptime_vm.callBuildOptionFn` arm (off `callCompilerFn`). No legacy
`compiler_lib` handler: the names are registered in `bound_fns` with a single
bailing stub only so `weldedCompilerFn` accepts them.

- String lifetime: setters dupe the arg into the persistent `Vm.gpa` (the
  Compilation allocator, threaded into both `tryEval` and `runBuildCallback` —
  not the per-eval VM arena) and write/append to the threaded `BuildConfig`.
  Getters read the field/slice or compute the target predicate from the triple.
- Dispatch routing (Option B): a `#run`/const-init entry that directly calls a
  compiler-domain/welded fn (`emit_llvm.entryNeedsVm`) runs on the VM with no
  legacy fallback regardless of the `-Dcomptime-flat` gate, so gate-OFF stays
  green without a legacy BuildOptions handler (P5.7 retires the legacy interp).
- Mark the 5 `platform/bundle.sx` getter-calling helpers `abi(.compiler)` (they
  are comptime-only bundler code; otherwise their now-welded getter calls trip
  the runtime-call gate).
- 37 `.ir` snapshots regenerated (std transitively imports build.sx → string-
  pool/type-table indices shift); verified `.ir`-only, zero behavior-stream diffs.

BuildOptions `compiler_call` strict bails gone (1609/1614/1615 strict-clean);
1616 now bails on a separate, pre-existing unported bitwise/shift VM gap (`shr`),
to port first in P5.6. 703/0 both gates.

Also sweep the outdated "flat memory" terminology to "comptime/byte-addressable"
across comptime_vm + the plan/checkpoint/CLAUDE docs: the comptime VM is
arena-backed, byte-addressable memory where `Addr` is a real host pointer, not a
flat contiguous address space (flag names `-Dcomptime-flat`/`SX_COMPTIME_FLAT` kept).

src/ir/lower/comptime.zig

@@ -495,7 +495,7 @@ pub fn runComptimeTypeFunc(self: *Lowering, func_id: FuncId, span: ast.Span) ?Ty
     // `getOrCreateThunks` is idempotent (cached in `protocol_thunk_map`), so the
     // later Pass-1c call reuses these. Guarded exactly like `emitDefaultContextGlobal`
     // (skip when the std allocator types aren't registered). This lets the
-    // flat-memory VM materialize a REAL lowering-time context (the func-refs are
+    // comptime VM materialize a REAL lowering-time context (the func-refs are
     // dispatchable on the VM via `call_indirect` → thunk → native malloc).
     {
         const tbl = &self.module.types;
@@ -640,7 +640,7 @@ pub fn evalComptimeString(self: *Lowering, expr: *const Node) ?[:0]const u8 {
     // dealloc thunks at the bottom of the dispatch.
     const ct_func_id = self.createComptimeFunction("__insert", expr, .string);
 
-    // NOTE: the flat-memory VM is intentionally NOT wired at this LOWERING-time
+    // NOTE: the comptime VM is intentionally NOT wired at this LOWERING-time
     // site. Unlike the emit-time const-init / `#run` folds (which run on fully
     // lowered IR), lowering-time IR can be malformed (e.g. a `ret Ref.none` left by
     // an unresolved name — see `0737`), and routing that through the VM is out of