ffi 0.3: large struct baseline (Big24, Big48) through sret return path

90/90 regression tests pass (+ffi-03-large-struct).

vendors/ffi_large_struct/{.h,.c} defines:
  Big24 — 24 B, three s64    (byval params + sret return)
  Big48 — 48 B, six s64      (same path, larger)

`make / rotate-or-reverse / sum` helpers per shape. The sx-side
example imports via `#source` only and declares matching structs +
hand-written #foreign decls.

Snapshot pins today's >16-byte aggregate ABI now that the
emit_llvm.zig sret-return transform is in place (previous commit).
That gives us a regression net for all four C-ABI aggregate slots
in one place:

  ≤8 B int       — i64 coercion          (ffi-01 vec-likes)
  9..16 B int    — [2 x i64] coercion    (ffi-02 Pair64/Quad32, 101)
  16 B HFA       — struct, no coercion    (ffi-02 Vec2/Vec4f)
  >16 B          — byval params + sret    (this commit)

vendors/ffi_large_struct/ffi_large_struct.c

@@ -0,0 +1,30 @@
+#include "ffi_large_struct.h"
+
+Big24 ffi_big24_make(long long a, long long b, long long c) {
+    Big24 r = { a, b, c };
+    return r;
+}
+
+Big24 ffi_big24_rotate(Big24 v) {
+    Big24 r = { v.c, v.a, v.b };
+    return r;
+}
+
+long long ffi_big24_sum(Big24 v) {
+    return v.a + v.b + v.c;
+}
+
+Big48 ffi_big48_make(long long a, long long b, long long c,
+                     long long d, long long e, long long f) {
+    Big48 r = { a, b, c, d, e, f };
+    return r;
+}
+
+Big48 ffi_big48_reverse(Big48 v) {
+    Big48 r = { v.f, v.e, v.d, v.c, v.b, v.a };
+    return r;
+}
+
+long long ffi_big48_sum(Big48 v) {
+    return v.a + v.b + v.c + v.d + v.e + v.f;
+}

vendors/ffi_large_struct/ffi_large_struct.h

@@ -0,0 +1,22 @@
+// FFI large-struct (>16 B) by-value roundtrips. These route through
+// the byval-pointer ABI path (caller copies onto its stack, hands the
+// callee a pointer; on AAPCS64 a separate `x8` indirect-return
+// register; on SysV AMD64 a hidden first arg). Distinct from the
+// register-pair / [2 x i64] / HFA paths the small-struct baseline
+// covers — locking those in here keeps the byval path honest.
+//
+//   Big24 — 24 B, three s64
+//   Big48 — 48 B, six s64
+
+typedef struct { long long a; long long b; long long c; }                 Big24;
+typedef struct { long long a; long long b; long long c;
+                 long long d; long long e; long long f; }                 Big48;
+
+Big24     ffi_big24_make  (long long a, long long b, long long c);
+Big24     ffi_big24_rotate(Big24 v);
+long long ffi_big24_sum   (Big24 v);
+
+Big48     ffi_big48_make  (long long a, long long b, long long c,
+                           long long d, long long e, long long f);
+Big48     ffi_big48_reverse(Big48 v);
+long long ffi_big48_sum   (Big48 v);