ffi 1.17: #jni_call(name, sig) literal-keyed slot interning

Two `#jni_call` sites with the same string-literal `(name, sig)` pair
now share a single `jclass` GlobalRef slot and a single `jmethodID`
slot, populated lazily on the first call to any matching site.
Non-literal sites keep the per-call `GetObjectClass` + `GetMethodID`
sequence from step 1.15.

Per-call-site lowering for literal sites:

  %cached_mid = load ptr, @SX_JNI_MID_<key>
  %is_cached  = icmp ne ptr %cached_mid, null
  br i1 %is_cached, cont, miss
miss:
  %local_cls  = GetObjectClass(env, target)
  %global_cls = NewGlobalRef(env, local_cls)     ; vtable slot 21
  store ptr %global_cls, @SX_JNI_CLS_<key>
  %fresh_mid  = GetMethodID(env, global_cls, name, sig)
  store ptr %fresh_mid, @SX_JNI_MID_<key>
  br cont
cont:
  %mid = phi ptr [%cached_mid, before], [%fresh_mid, miss]
  call <Type>Method(env, target, %mid, args...)

Wiring:
- `JniMsgSend.cache_key: ?CacheKey` (new) carries `(name_str,
  sig_str)` when both `name` and `sig` are string-literal AST nodes;
  empty for non-literal call sites.
- `lower.zig` populates `cache_key` from the AST.
- `emit_llvm.zig` `getOrCreateJniSlots(name, sig)` returns the
  `{cls_slot, mid_slot}` pair, creating and caching them on first
  lookup. Key is `name\x00sig` so the separator can't collide with
  any JNI identifier byte.
- `mangleJniKey` builds an LLVM-identifier suffix from the pair, used
  in the `@SX_JNI_{CLS,MID}_<suffix>` global names.

IR snapshot at `tests/expected/ffi-jni-call-03-methodid-sharing.ir`
updated: two call sites against literal `("noop", "()V")` now share
`@SX_JNI_CLS_noop____V` and `@SX_JNI_MID_noop____V`. Pre-1.17 snapshot
had two independent `GetMethodID` calls; post-1.17 has one global
slot pair plus per-call lazy-init branches.

Note: an unrelated regression in `examples/ffi-objc-call-12-rect-u64-returns.sx`
exists in the working tree (parse error from an in-progress C-import
block) and is left untouched.

src/ir/inst.zig

@@ -315,8 +315,12 @@ pub const ObjcMsgSend = struct {
 /// JNI dispatch payload. `env` is `JNIEnv*` (typed as ptr); `target`
 /// is a `jobject` for instance calls and a `jclass` for static calls.
 /// `name` and `sig` are pointers to NUL-terminated bytes (typically
-/// `[*]u8` from a string-literal `.ptr`). The dispatch sequence is
-/// expanded in emit_llvm.zig — see `Inst.jni_msg_send`.
+/// `[*]u8` from a string-literal `.ptr`). When the source-level
+/// `name` and `sig` are string literals, `cache_key` carries their
+/// content so emit_llvm.zig can intern a shared `jclass GlobalRef` +
+/// `jmethodID` slot keyed on `(name, sig)`; otherwise the lookup
+/// stays uncached. The dispatch sequence is expanded in
+/// emit_llvm.zig — see `Inst.jni_msg_send`.
 pub const JniMsgSend = struct {
     env: Ref,
     target: Ref,
@@ -324,6 +328,12 @@ pub const JniMsgSend = struct {
     sig: Ref,
     args: []const Ref,
     is_static: bool,
+    cache_key: ?CacheKey = null,
+};
+
+pub const CacheKey = struct {
+    name_str: []const u8,
+    sig_str: []const u8,
 };
 
 pub const BuiltinCall = struct {