Add (param :as type) annotations to all fn/lambda params across SX spec

Extend the type annotation system from defcomp-only to fn/lambda params:
- Infrastructure: sf-lambda, py/js-collect-params-loop, and bootstrap_py.py
  now recognize (name :as type) in param lists, extracting just the name
- bootstrap_py.py: add _extract_param_name() helper, fix _emit_for_each_stmt
- 521 type annotations across 22 .sx spec files (eval, types, adapters,
  transpilers, engine, orchestration, deps, signals, router, prove, etc.)
- Zero behavioral change: annotations are metadata for static analysis only
- All bootstrappers (Python, JS, G1) pass, 81/81 spec tests pass

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

shared/sx/ref/render.sx

@@ -72,18 +72,18 @@
 ;; --------------------------------------------------------------------------
 
 (define definition-form?
-  (fn (name)
+  (fn ((name :as string))
     (or (= name "define") (= name "defcomp") (= name "defisland")
         (= name "defmacro") (= name "defstyle") (= name "defhandler"))))
 
 
 (define parse-element-args
-  (fn (args env)
+  (fn ((args :as list) (env :as dict))
     ;; Parse (:key val :key2 val2 child1 child2) into (attrs-dict children-list)
     (let ((attrs (dict))
           (children (list)))
       (reduce
-        (fn (state arg)
+        (fn ((state :as dict) arg)
           (let ((skip (get state "skip")))
             (if skip
               (assoc state "skip" false "i" (inc (get state "i")))
@@ -101,12 +101,12 @@
 
 
 (define render-attrs
-  (fn (attrs)
+  (fn ((attrs :as dict))
     ;; Render an attrs dict to an HTML attribute string.
     ;; Used by adapter-html.sx and adapter-sx.sx.
     (join ""
       (map
-        (fn (key)
+        (fn ((key :as string))
           (let ((val (dict-get attrs key)))
             (cond
               ;; Boolean attrs
@@ -133,13 +133,13 @@
 ;; Handles both scheme-style ((test body) ...) and clojure-style
 ;; (test body test body ...).
 (define eval-cond
-  (fn (clauses env)
+  (fn ((clauses :as list) (env :as dict))
     (if (cond-scheme? clauses)
       (eval-cond-scheme clauses env)
       (eval-cond-clojure clauses env))))
 
 (define eval-cond-scheme
-  (fn (clauses env)
+  (fn ((clauses :as list) (env :as dict))
     (if (empty? clauses)
       nil
       (let ((clause (first clauses))
@@ -156,7 +156,7 @@
             (eval-cond-scheme (rest clauses) env)))))))
 
 (define eval-cond-clojure
-  (fn (clauses env)
+  (fn ((clauses :as list) (env :as dict))
     (if (< (len clauses) 2)
       nil
       (let ((test (first clauses))
@@ -173,12 +173,12 @@
 ;; process-bindings: evaluate let-binding pairs, return extended env.
 ;; bindings = ((name1 expr1) (name2 expr2) ...)
 (define process-bindings
-  (fn (bindings env)
+  (fn ((bindings :as list) (env :as dict))
     ;; env-extend (not merge) — Env is not a dict subclass, so merge()
     ;; returns an empty dict, losing all parent scope bindings.
     (let ((local (env-extend env)))
       (for-each
-        (fn (pair)
+        (fn ((pair :as list))
           (when (and (= (type-of pair) "list") (>= (len pair) 2))
             (let ((name (if (= (type-of (first pair)) "symbol")
                           (symbol-name (first pair))