abi: pass >16B aggregates by ptr-in-next-reg (Apple ARM64 ABI) + Path B for fn-ptr casts

Three stacked compiler bugs were causing iOS-sim chess to crash inside
[MTLTexture replaceRegion:...]. Fixing them lets every replaceRegion call
site succeed (1×1 RGBA8, 1MB R8 atlas, 440×440 chess pieces).

Path B for callconv(.c) fn-pointer casts:
- FunctionInfo now carries call_conv: CallConv (TypeInfo.CallConv) so
  function-type interning distinguishes sx-CC from C-CC. Inst.zig's
  Function.CallingConvention aliases the same enum.
- Parser accepts an optional `callconv(.c)` suffix on fn-pointer type
  spellings (factored into parseOptionalCallConv() shared with parseFnDecl
  and parseLambda).
- resolveFunctionType passes the parsed CC through functionTypeCC().
- .call_indirect reads fp.call_conv == .c and applies the C-ABI
  alloca+materialize for >16B aggregate args (Path A's behaviour at .call).

Apple ARM64 ABI (drop LLVM byval):
- Side-by-side asm diff vs clang's emission for the equivalent C call site
  showed LLVM's `byval` attribute lowers Apple-arm64 byval on the stack,
  while clang passes the struct via a pointer in the next int register
  (x2 for replaceRegion:). The runtime objc_msgSend dispatch path expects
  clang's convention.
- Dropped the byval attribute from the function-signature emission and
  from both call sites (.call and .call_indirect). The materialize-into-
  alloca + pass-plain-ptr pattern stays — the call site now matches
  clang's `mov x2, sp` exactly.
- Path A's sx-to-sx case continues to work since both ends use plain ptr
  (caller does alloca+store+pass, callee loads from the ptr in prologue).

Protocol dispatch (emitProtocolDispatch):
- Untargeted `null` lowers as const_null with type .void (per
  target_type orelse .void). The "wrap-value-in-alloca-pass-pointer"
  branch alloca'd a void slot, which LLVM's IRBuilder asserts on —
  EXC_BREAKPOINT in getTypeSizeInBits, manifesting as exit 133 / SIGTRAP
  when building the chess game. Fixed by re-emitting as
  constNull(void_ptr) when arg_ty == .void && expected_ty == void_ptr.
- is_pointer_ty only recognized .pointer, so [*]T (many_pointer) was
  alloca-wrapped — the heap pixels pointer from stbi_load was stored
  into a stack slot and the slot's address was passed as the *void arg.
  Fixed by extending the check to `.pointer or .many_pointer`.

metal.sx call sites + lifecycle guards:
- msg_replace (replaceRegion:, MTLRegion = 48B) and the two setScissorRect:
  sites (MTLScissorRect = 32B) now spell their fn-pointer types with
  by-value params + callconv(.c) — the *MTLRegion/@local workaround is
  gone.
- metal_begin_frame_ios bails before nextDrawable when pixel_w/h are 0
  (drawableSize 0×0 makes nextDrawable abort via XPC).
- metal_init_ios only sets drawableSize when dims are positive.
- begin_frame's encoder/cmd_buffer failure paths now clear self.drawable
  so a partial failure doesn't leak a drawable back into the pool.

Examples + tests:
- examples/86-callconv-c-fnptr-large-aggregate.sx — new, covers Path B
  with C-CC fn-ptr cast.
- examples/87-fnptr-cast-large-aggregate.sx — renamed from issue-0025.sx,
  covers Path B with default sx-CC (the negative case).
- examples/85-cc-c-large-aggregate.sx — from Session 60, covers Path A.
- examples/issue-0014.sx, issue-0024.sx, issue-0025.sx — removed
  (resolved earlier this work).

71 regression tests pass, 0 failed. Chess game builds clean for iOS sim
and reaches its frame loop without aborting. Runtime: chess UI still
doesn't render — remaining issue is in the UIKit lifecycle / CAMetalLayer
setup (legacy-app vs scene-API hybrid), not a compiler bug. See
current/CHECKPOINT.md "Next step" for the diagnosis + options.

src/parser.zig

@@ -471,10 +471,12 @@ pub const Parser = struct {
                 // '->' present: function type
                 self.advance(); // skip '->'
                 const return_type = try self.parseTypeExpr();
+                const call_conv = try self.parseOptionalCallConv();
                 return try self.createNode(start, .{ .function_type_expr = .{
                     .param_types = try param_types.toOwnedSlice(self.allocator),
                     .param_names = if (has_names) try param_names.toOwnedSlice(self.allocator) else null,
                     .return_type = return_type,
+                    .call_conv = call_conv,
                 } });
             }
             // No '->': tuple type (even for single element)
@@ -1236,22 +1238,7 @@ pub const Parser = struct {
         }
 
         // Optional calling convention: callconv(.c)
-        var call_conv: ast.CallingConvention = .default;
-        if (self.current.tag == .kw_callconv) {
-            self.advance();
-            try self.expect(.l_paren);
-            try self.expect(.dot);
-            if (self.current.tag != .identifier)
-                return self.fail("expected calling convention name after '.'");
-            const cc_name = self.tokenSlice(self.current);
-            if (std.mem.eql(u8, cc_name, "c")) {
-                call_conv = .c;
-            } else {
-                return self.fail("unknown calling convention");
-            }
-            self.advance();
-            try self.expect(.r_paren);
-        }
+        const call_conv = try self.parseOptionalCallConv();
 
         // Body: block `{ ... }`, arrow `=> expr;`, #builtin, #compiler, or #foreign marker
         var is_arrow = false;
@@ -2370,22 +2357,7 @@ pub const Parser = struct {
         }
 
         // Optional calling convention: callconv(.c)
-        var call_conv: ast.CallingConvention = .default;
-        if (self.current.tag == .kw_callconv) {
-            self.advance();
-            try self.expect(.l_paren);
-            try self.expect(.dot);
-            if (self.current.tag != .identifier)
-                return self.fail("expected calling convention name after '.'");
-            const cc_name = self.tokenSlice(self.current);
-            if (std.mem.eql(u8, cc_name, "c")) {
-                call_conv = .c;
-            } else {
-                return self.fail("unknown calling convention");
-            }
-            self.advance();
-            try self.expect(.r_paren);
-        }
+        const call_conv = try self.parseOptionalCallConv();
 
         // Two body forms:
         // (params) => expr          — expression lambda
@@ -2423,6 +2395,20 @@ pub const Parser = struct {
         return tag == .l_brace or tag == .arrow or tag == .hash_builtin or tag == .hash_compiler or tag == .hash_foreign or tag == .fat_arrow or tag == .kw_callconv;
     }
 
+    fn parseOptionalCallConv(self: *Parser) anyerror!ast.CallingConvention {
+        if (self.current.tag != .kw_callconv) return .default;
+        self.advance();
+        try self.expect(.l_paren);
+        try self.expect(.dot);
+        if (self.current.tag != .identifier)
+            return self.fail("expected calling convention name after '.'");
+        const cc_name = self.tokenSlice(self.current);
+        const cc: ast.CallingConvention = if (std.mem.eql(u8, cc_name, "c")) .c else return self.fail("unknown calling convention");
+        self.advance();
+        try self.expect(.r_paren);
+        return cc;
+    }
+
     fn isAssignOp(self: *const Parser) bool {
         return switch (self.current.tag) {
             .equal, .plus_equal, .minus_equal, .star_equal, .slash_equal, .percent_equal,