ffi M1.2 A.4b.iii: class_addMethod wires IMPs to the Obj-C runtime

For each instance method on a sx-defined '#objc_class', the
class-pair init constructor now:

  sel = sel_registerName("selector_string")
  imp = @__<Cls>_<method>_imp                  (M1.2 A.4b.ii)
  class_addMethod(cls, sel, imp, "<encoding>")

before objc_registerClassPair. The IMP trampoline (A.4b.ii)
already bridges C-ABI -> sx body. With registration in place,
'objc_msgSend(obj, sel_bump)' now routes to the trampoline,
which reads __sx_state ivar and forwards to '@<Cls>.<method>'.

To get selector + type-encoding strings out of lower.zig and
into emit_llvm, ObjcDefinedClassEntry gains a 'methods' slice:

  pub const ObjcDefinedMethodEntry = struct {
      sel: []const u8,       // mangled selector (M1.2 A.1's deriveObjcSelector)
      encoding: []const u8,  // type encoding (M1.2 A.1's objcTypeEncodingFromSignature)
      imp_name: []const u8,  // C-callconv trampoline symbol
  };

registerObjcDefinedClassMethods populates this when it declares
each method's body function; Module.setObjcDefinedClassMethods
attaches the slice to the cache entry by name. Static (class-
side) methods are skipped — A.4b only covers instance methods;
class-method hooks like '+layerClass' land in M2.1.

emit_llvm reads entry.methods and emits class_addMethod inside
the per-class init block, before objc_registerClassPair (the
runtime locks the method list at register time on some SDK
versions).

145-objc-class-method-dispatch.sx verifies end-to-end:
class_getMethodImplementation(SxFoo, sel_registerName("bump"))
returns non-null after main starts. Both niladic ('bump') and
single-arg ('add:') selectors checked.

Still gated (A.7): sx-side 'obj.bump()' calls. The dispatch
gate at lower.zig:4407 hasn't opened — A.5 (+alloc) and A.6
(-dealloc) need to land first so the integration test
ffi-objc-defined-class-01-instance.sx (full state round-trip)
can exercise the full lifecycle.

174 example tests pass (+1 from 145). zig build test green.

src/ir/module.zig

@@ -62,8 +62,21 @@ pub const Module = struct {
     pub const ObjcClassEntry = struct { name: []const u8, slot: GlobalId };
     /// Pointer back to the AST node lets later passes re-walk `members`
     /// for fields / methods / `#extends` / `#implements` without
-    /// duplicating that data here.
-    pub const ObjcDefinedClassEntry = struct { name: []const u8, decl: *const ast.ForeignClassDecl };
+    /// duplicating that data here. `methods` holds emit-time registration
+    /// info derived in lower.zig (selector mangling + type encoding +
+    /// IMP symbol name) so emit_llvm can call `class_addMethod` per
+    /// instance method without re-resolving types from the AST.
+    pub const ObjcDefinedClassEntry = struct {
+        name: []const u8,
+        decl: *const ast.ForeignClassDecl,
+        methods: []const ObjcDefinedMethodEntry = &.{},
+    };
+
+    pub const ObjcDefinedMethodEntry = struct {
+        sel: []const u8, // mangled Obj-C selector (`add:and:`)
+        encoding: []const u8, // Apple-runtime type encoding (`v@:ii`)
+        imp_name: []const u8, // C-callconv trampoline symbol (`__Cls_method_imp`)
+    };
 
     pub fn init(alloc: Allocator) Module {
         return .{
@@ -129,6 +142,18 @@ pub const Module = struct {
         self.objc_defined_class_cache.append(self.alloc, .{ .name = name, .decl = decl }) catch unreachable;
     }
 
+    /// Attach derived method-registration data to an existing
+    /// `objc_defined_class_cache` entry. emit_llvm reads this slice to
+    /// emit `class_addMethod` calls per instance method.
+    pub fn setObjcDefinedClassMethods(self: *Module, name: []const u8, methods: []const ObjcDefinedMethodEntry) void {
+        for (self.objc_defined_class_cache.items) |*entry| {
+            if (std.mem.eql(u8, entry.name, name)) {
+                entry.methods = methods;
+                return;
+            }
+        }
+    }
+
     pub fn addFunction(self: *Module, func: Function) FuncId {
         const id = FuncId.fromIndex(@intCast(self.functions.items.len));
         self.functions.append(self.alloc, func) catch unreachable;