ffi 3.2 A1 (xfail): add #selector("...") override regression test

Phase 3.2 xfail half. `#selector("explicit:string")` is the escape
hatch for cases where the sx-side method name doesn't conveniently
produce the target selector under the default mangling rule
(Phase 3.0 — split on `_`, each piece becomes a keyword with a
trailing `:`).

Surface form mirrors `#jni_method_descriptor("(Sig)Ret")` — sits
after the optional `-> ReturnType` and before the method body /
terminator.

Test fixture covers both lowering paths:

- Static method override: `NSObject.gimme()` with override
  "description" — exercises lowerObjcStaticCall (Phase 3.1).
- Instance method override: `NSDictionary.lookup(self, key)` with
  override "objectForKey:" — declared (parse + AST + lowering
  wiring) but not invoked at runtime (no real NSDictionary in
  scope). The declaration alone locks in the multi-arg-override path.

Pre-3.2: parser doesn't know `#selector`; snapshot captures
"expected ';'" at the override site, exit=1. Next commit (A2) wires
the lexer token, AST field, parser block, and lowering integration;
snapshot flips to working output.

165/165 example tests. Plan at
`~/.claude/plans/lets-see-options-for-merry-dijkstra.md`.

examples/ffi-objc-dsl-06-selector-override.sx

@@ -0,0 +1,41 @@
+// Phase 3 step 3.2 (PLAN-FFI.md): `#selector("explicit:string")`
+// override on `#objc_class` members. Escape hatch for cases where the
+// sx-side method name doesn't conveniently produce the target selector
+// through the default mangling rule (Phase 3.0 — split on `_`, each
+// piece becomes a keyword with a trailing `:`).
+//
+// Surface form mirrors `#jni_method_descriptor("(Sig)Ret")` — sits
+// after the optional `-> ReturnType` and before the body / terminator.
+//
+// Pre-3.2: the parser doesn't know the `#selector` token; snapshot
+// captures the parser error (exit=1). Next commit wires lexer + parser
+// + AST + lowering and the snapshot flips to working output.
+#import "modules/std.sx";
+#import "modules/compiler.sx";
+
+NSObject :: #foreign #objc_class("NSObject") {
+    // Default mangling would yield selector "gimme" — NSObject has no
+    // such IMP. The override pins it to the real selector
+    // "description". Static method (no `self: *Self` first param).
+    gimme :: () -> *void #selector("description");
+}
+
+// Instance-method override exercises a different lowering path
+// (`lowerObjcMethodCall` rather than `lowerObjcStaticCall`). Parse-
+// only on this side — main only invokes the static path because we
+// don't have a real NSDictionary in scope, but the declaration locks
+// in the parser + AST + lowering wiring for the multi-arg shape.
+NSDictionary :: #foreign #objc_class("NSDictionary") {
+    lookup :: (self: *Self, key: *void) -> *void #selector("objectForKey:");
+}
+
+main :: () -> s32 {
+    inline if OS == .macos {
+        d := NSObject.gimme();
+        print("static override non-null: {}\n", d != null);
+    }
+    inline if OS != .macos {
+        print("skipped (not macos)\n");
+    }
+    0;
+}