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`.

current/CHECKPOINT-FFI.md

@@ -511,8 +511,27 @@ type is the contract. Updated: `library/modules/platform/android.sx`,
 `examples/ffi-jni-class-03-static.sx`, `examples/ffi-jni-main-03-ctor.sx`,
 `examples/ffi-objc-dsl-05-static.sx`.
 
+Phase 3 step 3.2 in flight. Plan at
+`~/.claude/plans/lets-see-options-for-merry-dijkstra.md`. Three parts:
+(A) `#selector("...")` override, (B) golden mangling-table fixture,
+(C) uikit.sx migration to declarative `#objc_class` (5 clusters,
+foreign classes only — sx-defined classes wait for Phase 3.7).
+
+This commit lands A1 — the xfail half of the `#selector` cadence.
+`examples/ffi-objc-dsl-06-selector-override.sx` exercises the
+surface form (both static `NSObject.gimme()` with override "description"
+and an instance-method `NSDictionary.lookup` with override
+"objectForKey:"). The parser doesn't know the `#selector` token yet,
+so the snapshot captures the parser error and exit=1. Next commit
+(A2) wires lexer/parser/AST/lowering and flips the snapshot.
+
 Open work, in roughly the order they make sense:
-- **Phase 3 step 3.2** — `#selector("explicit:")` override + golden
+- **Phase 3 step 3.2 — A2 (make-green)** — wire the `#selector`
+  token and override behavior. Snapshot flips to working output.
+- **Phase 3 step 3.2 — B (golden mangling table)** — locked-in IR
+  fixture for the default mangling rule.
+- **Phase 3 step 3.2 — C1..C5** — uikit.sx migration, one cluster
+  per commit, chess regression after each.
   test for the default-mangling table. Escape hatch for selectors
   that don't fit the underscore-split rule (e.g. `tableView_
   numberOfRowsInSection_` with an asymmetric keyword count).

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;
+}

tests/expected/ffi-objc-dsl-06-selector-override.exit

@@ -0,0 +1 @@
+1

tests/expected/ffi-objc-dsl-06-selector-override.txt

@@ -0,0 +1 @@
+/Users/agra/projects/sx/examples/ffi-objc-dsl-06-selector-override.sx:20:26: error: expected ';'