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/router.sx

@@ -18,7 +18,7 @@
 ;; "/docs/" → ("docs")
 
 (define split-path-segments
-  (fn (path)
+  (fn ((path :as string))
     (let ((trimmed (if (starts-with? path "/") (slice path 1) path)))
       (let ((trimmed2 (if (and (not (empty? trimmed))
                                (ends-with? trimmed "/"))
@@ -36,7 +36,7 @@
 ;;                   {"type" "param" "value" "slug"})
 
 (define make-route-segment
-  (fn (seg)
+  (fn ((seg :as string))
     (if (and (starts-with? seg "<") (ends-with? seg ">"))
       (let ((param-name (slice seg 1 (- (len seg) 1))))
         (let ((d {}))
@@ -49,7 +49,7 @@
         d))))
 
 (define parse-route-pattern
-  (fn (pattern)
+  (fn ((pattern :as string))
     (let ((segments (split-path-segments pattern)))
       (map make-route-segment segments))))
 
@@ -60,13 +60,13 @@
 ;; Returns params dict if match, nil if no match.
 
 (define match-route-segments
-  (fn (path-segs parsed-segs)
+  (fn ((path-segs :as list) (parsed-segs :as list))
     (if (not (= (len path-segs) (len parsed-segs)))
       nil
       (let ((params {})
             (matched true))
         (for-each-indexed
-          (fn (i parsed-seg)
+          (fn ((i :as number) (parsed-seg :as dict))
             (when matched
               (let ((path-seg (nth path-segs i))
                     (seg-type (get parsed-seg "type")))
@@ -88,7 +88,7 @@
 ;; Returns params dict (may be empty for exact matches) or nil.
 
 (define match-route
-  (fn (path pattern)
+  (fn ((path :as string) (pattern :as string))
     (let ((path-segs (split-path-segments path))
           (parsed-segs (parse-route-pattern pattern)))
       (match-route-segments path-segs parsed-segs))))
@@ -101,11 +101,11 @@
 ;; Returns matching entry with "params" added, or nil.
 
 (define find-matching-route
-  (fn (path routes)
+  (fn ((path :as string) (routes :as list))
     (let ((path-segs (split-path-segments path))
           (result nil))
       (for-each
-        (fn (route)
+        (fn ((route :as dict))
           (when (nil? result)
             (let ((params (match-route-segments path-segs (get route "parsed"))))
               (when (not (nil? params))