ffi 2.8: JNI descriptor derivation + table-driven Zig unit tests

New `src/ir/jni_descriptor.zig`:
  - `writeType(allocator, buf, ctx, type_node)` appends one JNI
    descriptor for an sx type AST node.
  - `deriveMethod(allocator, ctx, method)` returns the full
    `(args)ret` descriptor for a `ForeignMethodDecl`, skipping the
    implicit `self` for instance methods.
  - `Context.enclosing_path` resolves `*Self` to its `L<path>;` form.

Primitive table: void→V, bool→Z, s8/u8→B, s16→S, u16→C, s32→I,
s64→J, f32→F, f64→D. Arrays: `[]T` / `[*]T` / `[N]T` → `[<elem>`.
`*Self` → `L<enclosing>;`. Cross-class `*Foo` → explicit
`CrossClassRefNotYetSupported` error (lands in step 2.9 with the
ForeignClassDecl registry lookup).

Tests in `src/ir/jni_descriptor.test.zig`: primitive table coverage,
void-on-null, *Self, slice, cross-class-fail-fast, plus three
deriveMethod scenarios (instance, static, multi-param, slice param).

Step 2.8 is internal compiler work — derivation isn't observable at
the sx surface until call-site lowering at step 2.11. The cadence
rule's xfail-then-green pattern presupposes a snapshot harness that
doesn't apply to internal-only functions; the rule re-applies at
2.11 where end-to-end observation returns.

zig build test passes; 126/126 examples still green.

src/ir/jni_descriptor.zig

@@ -0,0 +1,128 @@
+// JNI descriptor derivation for #jni_class methods (Phase 2 step 2.8).
+//
+// Walks sx parameter / return type AST nodes through the standard JNI
+// signature alphabet (JLS §4.3.3 and JNI spec §3.3) to produce the
+// descriptor string consumed by `GetMethodID` / `GetStaticMethodID`.
+//
+//   void          → V
+//   bool          → Z   (jboolean)
+//   s8            → B   (jbyte)
+//   s16           → S   (jshort)
+//   s32           → I   (jint)
+//   s64           → J   (jlong)
+//   u8            → B   (jbyte — JNI bytes are signed; sx u8 still bridges via B)
+//   u16           → C   (jchar — unsigned 16-bit)
+//   f32           → F   (jfloat)
+//   f64           → D   (jdouble)
+//   []T           → [<elem>
+//   [*]T          → [<elem>   (sx many-pointer treated as array for now)
+//   *Self         → L<enclosing-foreign-path>;
+//   *Foo          → L<Foo's foreign path>;   (cross-class — step 2.9)
+//
+// `#jni_method_descriptor("...")` (step 2.6) overrides this whole walk
+// when set; sema/lowering use the override verbatim.
+
+const std = @import("std");
+const ast = @import("../ast.zig");
+
+const Node = ast.Node;
+
+pub const DeriveError = error{
+    UnknownPrimitive,
+    UnsupportedType,
+    CrossClassRefNotYetSupported, // *Foo for non-Self — lands in step 2.9
+    OutOfMemory,
+};
+
+pub const Context = struct {
+    /// Foreign path of the enclosing #jni_class — used to resolve `*Self`.
+    /// e.g. "android/view/View".
+    enclosing_path: []const u8,
+};
+
+/// Appends a single JNI type-descriptor to `buf` for `type_node`.
+/// A null type_node represents a void return ('V').
+pub fn writeType(
+    allocator: std.mem.Allocator,
+    buf: *std.ArrayList(u8),
+    ctx: Context,
+    type_node: ?*const Node,
+) DeriveError!void {
+    if (type_node == null) {
+        try buf.append(allocator, 'V');
+        return;
+    }
+    const tn = type_node.?;
+    switch (tn.data) {
+        .type_expr => |te| {
+            const ch = primitiveChar(te.name) orelse return DeriveError.UnknownPrimitive;
+            try buf.append(allocator, ch);
+        },
+        .slice_type_expr => |sl| {
+            try buf.append(allocator, '[');
+            try writeType(allocator, buf, ctx, sl.element_type);
+        },
+        .many_pointer_type_expr => |mp| {
+            try buf.append(allocator, '[');
+            try writeType(allocator, buf, ctx, mp.element_type);
+        },
+        .array_type_expr => |arr| {
+            try buf.append(allocator, '[');
+            try writeType(allocator, buf, ctx, arr.element_type);
+        },
+        .pointer_type_expr => |ptr| {
+            // *Self → L<enclosing-foreign-path>;
+            const inner = ptr.pointee_type;
+            if (inner.data == .type_expr and std.mem.eql(u8, inner.data.type_expr.name, "Self")) {
+                try buf.append(allocator, 'L');
+                try buf.appendSlice(allocator, ctx.enclosing_path);
+                try buf.append(allocator, ';');
+                return;
+            }
+            return DeriveError.CrossClassRefNotYetSupported;
+        },
+        else => return DeriveError.UnsupportedType,
+    }
+}
+
+/// Derives the full `(args)ret` method descriptor for a `ForeignMethodDecl`.
+/// The first param is skipped when `is_static == false` (it's the implicit
+/// `self: *Self` receiver, which doesn't appear in the JNI descriptor).
+pub fn deriveMethod(
+    allocator: std.mem.Allocator,
+    ctx: Context,
+    method: ast.ForeignMethodDecl,
+) DeriveError![]u8 {
+    var buf: std.ArrayList(u8) = .empty;
+    errdefer buf.deinit(allocator);
+
+    try buf.append(allocator, '(');
+    const start: usize = if (method.is_static) 0 else 1;
+    if (method.params.len < start) return DeriveError.UnsupportedType;
+    for (method.params[start..]) |param| {
+        try writeType(allocator, &buf, ctx, param);
+    }
+    try buf.append(allocator, ')');
+    try writeType(allocator, &buf, ctx, method.return_type);
+
+    return buf.toOwnedSlice(allocator);
+}
+
+fn primitiveChar(name: []const u8) ?u8 {
+    const table = [_]struct { name: []const u8, ch: u8 }{
+        .{ .name = "void", .ch = 'V' },
+        .{ .name = "bool", .ch = 'Z' },
+        .{ .name = "s8", .ch = 'B' },
+        .{ .name = "u8", .ch = 'B' },
+        .{ .name = "s16", .ch = 'S' },
+        .{ .name = "u16", .ch = 'C' },
+        .{ .name = "s32", .ch = 'I' },
+        .{ .name = "s64", .ch = 'J' },
+        .{ .name = "f32", .ch = 'F' },
+        .{ .name = "f64", .ch = 'D' },
+    };
+    for (table) |entry| {
+        if (std.mem.eql(u8, name, entry.name)) return entry.ch;
+    }
+    return null;
+}