extern: caller-supplied keyword slots (kw = ...)

[simontreanor]

Closes the Caller-varying keyword arguments backlog item added in #20.

The gap

Pinned kwargs (DESIGN.md §6) accepted only literals fixed at the declaration, so requests.get(url, timeout = t) with a caller-supplied t needed a separate extern per call shape. Python's API culture is optional-kwargs-with-defaults, which made this the boundary friction a real user was likeliest to meet first.

The feature

A ... in place of the literal takes the keyword's value from the caller:

extern parseInt : string -> int -> int = int(base = ...)
extern openText : string -> string -> Seq string = builtins.open(mode = "rt", encoding = ...)
extern writeText : Path -> string -> string -> int = .write_text(encoding = ...)

parseInt "ff" 16   →  int("ff", base=16)
openText p enc     →  builtins.open(p, mode="rt", encoding=enc)
writeText p t enc  →  p.write_text(t, encoding=enc)

The spelling is Python's own stub-file placeholder (def get(url, timeout=...)), lexed as one token so . . . stays three dots.

Binding rule. Positional, mirroring a Python call: the target takes the leading arguments positionally and the slots take the trailing ones in the order the keywords are written. Pinned literals consume no argument, so the two mix freely: m.f(a=1, b=..., c="x", d=...) at arity 3 emits m.f(s, a=1, b=i, c="x", d=b).

Rejections. A slot claims one argument of the declared arrow, so the type must have one to spare. A receiver takes the first argument and a nullary extern's only argument is the unit lowering drops, so both are diagnosed rather than silently mis-lowered.

Under-application. functools.partial cannot carry a keyword whose value has not arrived, so an under-applied slot extern becomes a lambda over the remaining arguments:

parseInt "ff"  →  lambda _pf_k0: int("ff", base=_pf_k0)
parseInt       →  lambda _pf_k0, _pf_k1: int(_pf_k0, base=_pf_k1)

Already-supplied arguments, and a method extern's receiver, bind to temporaries first, so they evaluate at application time exactly as functools.partial would have evaluated them rather than once per later call.

Scope

The type is untouched. A slot changes only where an argument lands in the emitted call, so inference, effects and arity are unchanged, and src/types/ needed no edit. src/python_emitter/ needed none either: PyExpr::CallKw already held arbitrary expressions. Strictly additive, so every existing extern behaves as before.

Also updated the tree-sitter grammar (extern_slot), since editors using it would otherwise fail to parse a slot extern. The TextMate grammars only highlight the extern keyword, so they need nothing.

Tests

7 new in tests/compile.rs (placement, mixed literal/slot ordering, receiver form, partial-to-lambda, eager evaluation of supplied args and receiver, the three rejections, one e2e), 4 new roundtrip cases, 1 new lexer test, 1 new tree-sitter corpus case.

856 Rust tests pass, 42/42 tree-sitter corpus, cargo fmt --check and cargo clippy --all-targets clean. Verified cross-module too: a slot extern binds to a lambda at module top level and a dependent module calls it n-ary.