comptime compiler-API: Phase 1 foundation + Phase 2.1 weld plan

Introduce the welded comptime `compiler` library (`#library "compiler"` +
`abi(.zig) extern compiler`), per design/comptime-compiler-api.md, and unify
`callconv(...)` into the new `abi(...)` annotation.

abi(...) replaces callconv(...):
- New ABI enum { default, c, zig, pure }; `abi(.c|.zig|.pure)` parses in the
  postfix slot before extern/export (and standalone). `kw_callconv` -> `kw_abi`.
- Migrated 52 sx files, the call-convention-mismatch diagnostic, and docs
  (readme/specs) from `callconv(.c)` to `abi(.c)`.

Phase 1 — welded compiler library (parse -> registry -> validation -> bridge):
- `abi(.zig) extern compiler` parses on fn decls (carries abi/extern_lib) and
  struct decls (StructDecl.abi/extern_lib).
- `#library "compiler"` is the comptime-only internal surface — never dlopen'd.
- src/ir/compiler_lib.zig: the binding registry (the safety boundary). `Field`
  welded to StructInfo.Field with layout baked from the real Zig type
  (@offsetOf/@sizeOf); `findType`/`findFn`. Welded structs are layout-validated
  at registration (field set + total size) as a header checked against the impl.
- Host-call bridge: a `fn abi(.zig) extern compiler` dispatches under the
  comptime interp to its registered Zig handler (intern/text_of round-trip),
  never dlsym. IR Function.compiler_welded; validated in declareFunction.
- Comptime-only enforcement: a runtime call to a welded fn is a clean
  build-gating error (emitCall), not an undefined-symbol link failure.

Phase 2.1 — byte-layout weld foundation:
- Decision: full byte-layout weld (sx struct laid out byte-identically to the
  bound Zig type). Registered StructInfo (first non-natural / Zig-reordered
  layout). `computeWeldPlan` — pure offset-ordered element plan + padding +
  sx-field->LLVM-element remap; unit-tested. Emit/interp wiring is the next
  sub-step (2.2+, see current/CHECKPOINT-COMPILER-API.md).

Examples: 0625/0626 (welded struct + fn round-trip), 1183/1184/1185
(layout-mismatch, unexported-fn, runtime-call diagnostics).

src/ir/lower/decl.zig

@@ -10,6 +10,7 @@ const unescape = @import("../../unescape.zig");
 const errors = @import("../../errors.zig");
 const program_index_mod = @import("../program_index.zig");
 const resolver_mod = @import("../resolver.zig");
+const compiler_lib = @import("../compiler_lib.zig");
 const ProgramIndex = program_index_mod.ProgramIndex;
 const GlobalInfo = program_index_mod.GlobalInfo;
 const ModuleConstInfo = program_index_mod.ModuleConstInfo;
@@ -497,7 +498,7 @@ pub fn detectContextDecl(decls: []const *const Node) bool {
 /// `__sx_<name>_impl` with the ctx param) lands in Step 4 proper.
 pub fn funcWantsImplicitCtx(self: *const Lowering, fd: *const ast.FnDecl) bool {
     if (!self.implicit_ctx_enabled) return false;
-    if (fd.call_conv == .c) return false;
+    if (fd.abi == .c) return false;
     // `extern` imports and `export` defines are external C symbols —
     // C ABI, no sx context (Phase 2, gap iv).
     if (fd.extern_export != .none) return false;
@@ -2256,11 +2257,11 @@ pub fn declareFunction(self: *Lowering, fd: *const ast.FnDecl, name: []const u8)
     }
 
     // `extern` declarations are external C symbols by definition — promote
-    // them to callconv(.c) when the user didn't write it explicitly. This keeps
+    // them to abi(.c) when the user didn't write it explicitly. This keeps
     // fn-ptr coercion type-safe: anything typed by name as `(args) -> ret` of an
-    // `extern` decl can be assigned to / passed as a `callconv(.c)` fn-pointer
+    // `extern` decl can be assigned to / passed as a `abi(.c)` fn-pointer
     // without a call-convention mismatch.
-    const cc: Function.CallingConvention = if (fd.call_conv == .c or is_extern_decl or fd.extern_export == .export_) .c else .default;
+    const cc: Function.CallingConvention = if (fd.abi == .c or is_extern_decl or fd.extern_export == .export_) .c else .default;
 
     // Symbol-name override: `extern … "csym"` / `export … "csym"` (fd.extern_name).
     // Declare under the C name and map the sx name → C name so call sites resolve
@@ -2296,9 +2297,29 @@ pub fn declareFunction(self: *Lowering, fd: *const ast.FnDecl, name: []const u8)
     func.source_file = self.current_source_file;
     func.is_variadic = is_variadic;
     func.has_implicit_ctx = wants_ctx;
+    if (weldedCompilerFn(self, fd, name)) func.compiler_welded = true;
     self.fn_decl_fids.put(fd, fid) catch {};
 }
 
+/// A `fn abi(.zig) extern <lib>` binds the comptime `compiler` library. Validate
+/// it (the bound lib must be `compiler`; the name must be on the function-export
+/// list) and return whether it is a welded compiler function — the interpreter
+/// dispatches such a call to its registered Zig handler instead of dlsym. Any
+/// failure is a build-gating `.err` (never a silent fall-through to dlsym).
+fn weldedCompilerFn(self: *Lowering, fd: *const ast.FnDecl, name: []const u8) bool {
+    if (fd.abi != .zig) return false;
+    const diags = self.diagnostics;
+    if (fd.extern_lib == null or !std.mem.eql(u8, fd.extern_lib.?, compiler_lib.lib_name)) {
+        if (diags) |d| d.addFmt(.err, fd.name_span, "abi(.zig) function '{s}' must bind the compiler library — write `extern {s}`", .{ name, compiler_lib.lib_name });
+        return false;
+    }
+    if (compiler_lib.findFn(name) == null) {
+        if (diags) |d| d.addFmt(.err, fd.name_span, "'{s}' is not a function exported by the '{s}' library", .{ name, compiler_lib.lib_name });
+        return false;
+    }
+    return true;
+}
+
 /// Register a namespaced import's OWN functions under their module-qualified
 /// name (`ns.fn`), giving each a UNIQUE FuncId in the function table. Two
 /// modules each exporting a top-level `parse` otherwise collide in the
@@ -2553,7 +2574,7 @@ pub fn lowerFunctionBodyInto(self: *Lowering, fd: *const ast.FnDecl, fid: FuncId
     func.is_extern = false; // promote from extern stub to real function
     // `export` defines force external linkage + C ABI (Phase 2, gaps i+ii).
     func.linkage = if (isExportedEntryName(name) or fd.extern_export == .export_) .external else .internal;
-    if (fd.call_conv == .c or fd.extern_export == .export_) func.call_conv = .c;
+    if (fd.abi == .c or fd.extern_export == .export_) func.call_conv = .c;
     // Set inst_counter to param count (params occupy refs 0..N-1). IR params
     // = AST params + 1 if the function carries `__sx_ctx` at slot 0.
     const ctx_slots: usize = if (func.has_implicit_ctx) 1 else 0;
@@ -2589,7 +2610,7 @@ pub fn lowerFunctionBodyInto(self: *Lowering, fd: *const ast.FnDecl, fid: FuncId
         scope.put(p.name, .{ .ref = slot, .ty = pty, .is_alloca = true });
     }
 
-    // Inbound entry points + callconv(.c) sx functions: bind current_ctx_ref
+    // Inbound entry points + abi(.c) sx functions: bind current_ctx_ref
     // to the static default before any user code runs.
     if (!wants_ctx and self.implicit_ctx_enabled) {
         if (self.program_index.global_names.get("__sx_default_context")) |dctx_gi| {
@@ -2695,7 +2716,7 @@ pub fn lowerFunction(self: *Lowering, fd: *const ast.FnDecl, name: []const u8, i
     }
 
     // Set calling convention. `export` defines promote to C ABI (gap ii).
-    if (fd.call_conv == .c or fd.extern_export == .export_) {
+    if (fd.abi == .c or fd.extern_export == .export_) {
         self.builder.currentFunc().call_conv = .c;
     }
 
@@ -2729,7 +2750,7 @@ pub fn lowerFunction(self: *Lowering, fd: *const ast.FnDecl, name: []const u8, i
         scope.put(p.name, .{ .ref = slot, .ty = pty, .is_alloca = true });
     }
 
-    // Inbound entry points + callconv(.c) sx functions: bind
+    // Inbound entry points + abi(.c) sx functions: bind
     // current_ctx_ref to &__sx_default_context. See companion comment
     // in `lowerFunction` for the same case.
     if (!wants_ctx_lf and self.implicit_ctx_enabled) {