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/nominal.zig

@@ -6,6 +6,7 @@ const mod_mod = @import("../module.zig");
 const type_bridge = @import("../type_bridge.zig");
 const program_index_mod = @import("../program_index.zig");
 const resolver_mod = @import("../resolver.zig");
+const compiler_lib = @import("../compiler_lib.zig");
 const StructTemplate = program_index_mod.StructTemplate;
 const TemplateParam = program_index_mod.TemplateParam;
 
@@ -673,7 +674,13 @@ pub fn registerStructDecl(self: *Lowering, sd: *const ast.StructDecl, source_fil
     // any forward-reference stub. Same-name structs in DIFFERENT sources get
     // distinct TypeIds instead of last-wins clobbering the first.
     const info: types.TypeInfo = .{ .@"struct" = .{ .name = name_id, .fields = fields.items } };
-    _ = self.internNamedTypeDecl(decl_key, name_id, info, nominal_id);
+    const struct_tid = self.internNamedTypeDecl(decl_key, name_id, info, nominal_id);
+
+    // Welded `struct abi(.zig) extern compiler { … }`: the sx declaration is a
+    // header checked against the compiler's real Zig type — validate the layout
+    // matches the binding registry (a mismatch is a build error). See
+    // design/comptime-compiler-api.md.
+    if (sd.abi == .zig) validateWeldedStruct(self, sd, struct_tid, fields.items);
 
     // Store field defaults for struct literal lowering
     if (sd.field_defaults.len > 0) {
@@ -709,6 +716,51 @@ pub fn registerStructDecl(self: *Lowering, sd: *const ast.StructDecl, source_fil
     }
 }
 
+/// Validate a welded `struct abi(.zig) extern <lib> { … }` against the `compiler`
+/// library's binding registry: the bound library must be `compiler`, the name
+/// must be on the export list, and the sx-declared layout must match the real Zig
+/// type's (the sx side is a *header* checked against the implementation). Any
+/// failure is a build-gating `.err` diagnostic — never a silent reinterpretation.
+fn validateWeldedStruct(self: *Lowering, sd: *const ast.StructDecl, tid: TypeId, fields: []const types.TypeInfo.StructInfo.Field) void {
+    const diags = self.diagnostics orelse return;
+    const table = &self.module.types;
+
+    // A span that points into the struct (its first field, else zero) — the decl
+    // has no name span of its own.
+    const span: ast.Span = if (sd.field_types.len > 0) sd.field_types[0].span else .{ .start = 0, .end = 0 };
+
+    // The bound library must be the sole welded source.
+    if (sd.extern_lib == null or !std.mem.eql(u8, sd.extern_lib.?, compiler_lib.lib_name)) {
+        diags.addFmt(.err, span, "abi(.zig) struct '{s}' must bind the compiler library — write `extern {s}`", .{ sd.name, compiler_lib.lib_name });
+        return;
+    }
+
+    // The name must be on the curated export list (the safety boundary).
+    const bt = compiler_lib.findType(sd.name) orelse {
+        diags.addFmt(.err, span, "'{s}' is not a type exported by the '{s}' library", .{ sd.name, compiler_lib.lib_name });
+        return;
+    };
+
+    // Build the observed sx layout (field name + computed size) and total size.
+    var sx_fields = std.ArrayList(compiler_lib.SxField).empty;
+    defer sx_fields.deinit(self.alloc);
+    for (fields) |f| {
+        sx_fields.append(self.alloc, .{
+            .name = table.getString(f.name),
+            .size = table.typeSizeBytes(f.ty),
+        }) catch return;
+    }
+    const total = table.typeSizeBytes(tid);
+
+    const mismatch = compiler_lib.validateStructLayout(bt, sx_fields.items, total) orelse return;
+    switch (mismatch) {
+        .field_count => |m| diags.addFmt(.err, span, "welded type '{s}' has {d} field(s) in the compiler library but the declaration has {d}", .{ sd.name, m.expected, m.got }),
+        .field_name => |m| diags.addFmt(.err, span, "welded type '{s}' field {d} is named '{s}' in the compiler library, not '{s}'", .{ sd.name, m.index, m.expected, m.got }),
+        .field_size => |m| diags.addFmt(.err, span, "welded type '{s}' field '{s}' is {d} byte(s) in the compiler library but {d} as declared", .{ sd.name, m.name, m.expected, m.got }),
+        .total_size => |m| diags.addFmt(.err, span, "welded type '{s}' is {d} byte(s) in the compiler library but {d} as declared (padding/alignment mismatch)", .{ sd.name, m.expected, m.got }),
+    }
+}
+
 /// Register a top-level ENUM decl under a per-decl nominal identity (E6a) —
 /// the enum twin of `registerStructDecl`. A GENUINE same-name shadow already
 /// reserved its DISTINCT slot up-front in `scanDecls` (the first at id 0, the