Add typed params to 67 primitives, implement check-primitive-call

Annotate all primitives in primitives.sx with (:as type) param types
where meaningful (67/80 — 13 polymorphic ops stay untyped). Add
parse_primitive_param_types() to boundary_parser.py for extraction.
Implement check-primitive-call in types.sx with full positional + rest
param validation, thread prim-param-types through check-body-walk,
check-component, and check-all. 10 new tests (438 total, all pass).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

shared/sx/ref/boundary_parser.py

@@ -169,6 +169,83 @@ def parse_primitives_by_module() -> dict[str, frozenset[str]]:
     return {mod: frozenset(names) for mod, names in modules.items()}
 
 
+def _parse_param_type(param) -> tuple[str, str | None, bool]:
+    """Parse a single param entry from a :params list.
+
+    Returns (name, type_or_none, is_rest).
+    A bare symbol like ``x`` → ("x", None, False).
+    A typed form ``(x :as number)`` → ("x", "number", False).
+    The ``&rest`` marker is tracked externally.
+    """
+    if isinstance(param, Symbol):
+        return (param.name, None, False)
+    if isinstance(param, list) and len(param) == 3:
+        # (name :as type)
+        name_sym, kw, type_val = param
+        if (isinstance(name_sym, Symbol)
+                and isinstance(kw, Keyword) and kw.name == "as"):
+            type_str = type_val.name if isinstance(type_val, Symbol) else str(type_val)
+            return (name_sym.name, type_str, False)
+    return (str(param), None, False)
+
+
+def parse_primitive_param_types() -> dict[str, dict]:
+    """Parse primitives.sx and extract param type info for each primitive.
+
+    Returns a dict mapping primitive name to param type descriptor::
+
+        {
+            "+":  {"positional": [],           "rest_type": "number"},
+            "/":  {"positional": [("a", "number"), ("b", "number")], "rest_type": None},
+            "get": {"positional": [("coll", None), ("key", None)],  "rest_type": None},
+        }
+
+    Each positional entry is (name, type_or_none).  rest_type is the
+    type of the &rest parameter (or None if no &rest, or None if untyped &rest).
+    """
+    source = _read_file("primitives.sx")
+    exprs = parse_all(source)
+    result: dict[str, dict] = {}
+
+    for expr in exprs:
+        if not isinstance(expr, list) or len(expr) < 2:
+            continue
+        if not isinstance(expr[0], Symbol) or expr[0].name != "define-primitive":
+            continue
+
+        name = expr[1]
+        if not isinstance(name, str):
+            continue
+
+        params_list = _extract_keyword_arg(expr, "params")
+        if not isinstance(params_list, list):
+            continue
+
+        positional: list[tuple[str, str | None]] = []
+        rest_type: str | None = None
+        i = 0
+        while i < len(params_list):
+            item = params_list[i]
+            if isinstance(item, Symbol) and item.name == "&rest":
+                # Next item is the rest param
+                if i + 1 < len(params_list):
+                    rname, rtype, _ = _parse_param_type(params_list[i + 1])
+                    rest_type = rtype
+                i += 2
+            else:
+                pname, ptype, _ = _parse_param_type(item)
+                if pname != "&rest":
+                    positional.append((pname, ptype))
+                i += 1
+
+        # Only store if at least one param has a type
+        has_types = rest_type is not None or any(t is not None for _, t in positional)
+        if has_types:
+            result[name] = {"positional": positional, "rest_type": rest_type}
+
+    return result
+
+
 def parse_boundary_sx() -> tuple[frozenset[str], dict[str, frozenset[str]]]:
     """Parse all boundary sources and return (io_names, {service: helper_names}).