go: Phase 7 foundation — generics syntax through parser/typer/eval [shapes-static-types-bidirectional]

gp-parse-type-params consumes the optional [NAMES CONSTRAINT, ...]
clause after a func name. AST stays backward-compatible: 5-slot
func-decl when no [...] is present, 6-slot when it is.

Typer binds each type-param name as (:ty-param NAME CONSTRAINT) so
body's (:ty-name "T") references resolve. Eval is type-erasing —
ignores type info, dispatches by name + arity.

10 new tests: parse (3), types (5), eval (2). Total 527/527.

Shape: the field binding-group from the canonical kit now feeds
6 consumers (struct fields, var-decls, const-decls, params,
receivers, type-params). Confirms it as a TRUE cross-deliverable
shape — sister-plan diary documents the 5 roles binding-groups
take and why the kit should expose ONE parser + pluggable validators.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

lib/go/types.sx

@@ -749,11 +749,19 @@
 (define
   go-check-func-decl
   ;; Bind the function in the outer ctx (so recursion works), extend
-  ;; ctx with params, check the body. Returns the outer ctx with the
-  ;; function bound, or :type-error.
+  ;; ctx with type params + value params, check the body. Returns the
+  ;; outer ctx with the function bound, or :type-error.
+  ;;
+  ;; Type parameters become opaque type variables in the body's ctx:
+  ;; each name `T` is bound as a type alias to (:ty-param "T") so the
+  ;; checker treats references to T as "this type", not "unknown".
+  ;; Constraint enforcement (T satisfies `comparable` etc.) is a
+  ;; later refinement; v0 just allows any operation that's polymorphic
+  ;; under the constraint `any`.
   (fn (ctx decl)
     (let ((name (nth decl 1)) (params (nth decl 2))
-          (results (nth decl 3)) (body (nth decl 4)))
+          (results (nth decl 3)) (body (nth decl 4))
+          (type-params (cond (> (len decl) 5) (nth decl 5) :else nil)))
       (let ((fn-ty
               (list :ty-func
                 (go-decl-params-to-ty-list params) results)))
@@ -762,10 +770,40 @@
             (= body nil) ctx-with-fn
             (and (list? body) (= (first body) :block))
             (let ((body-ctx
-                    (go-extend-with-params ctx-with-fn params)))
+                    (go-extend-with-type-params
+                      (go-extend-with-params ctx-with-fn params)
+                      type-params)))
               (let ((err
                       (go-check-block body-ctx (nth body 1) results)))
                 (cond
                   (go-type-error? err) err
                   :else ctx-with-fn)))
             :else ctx-with-fn))))))
+
+(define
+  go-extend-with-type-params
+  ;; Each (:field NAMES CONSTRAINT) field contributes opaque type
+  ;; vars: bind each NAME as a type alias to (:ty-param NAME). The
+  ;; constraint type is stored alongside so future "constraint
+  ;; satisfaction" checks can find it; for v0 it's informational.
+  (fn (ctx type-params)
+    (cond
+      (or (= type-params nil) (= (len type-params) 0)) ctx
+      :else
+      (let ((field (first type-params)))
+        (let ((names (nth field 1)) (constraint (nth field 2)))
+          (go-extend-with-type-params
+            (go-extend-with-type-param-names ctx names constraint)
+            (rest type-params)))))))
+
+(define
+  go-extend-with-type-param-names
+  (fn (ctx names constraint)
+    (cond
+      (= (len names) 0) ctx
+      :else
+      (let ((nm (first names)))
+        (go-extend-with-type-param-names
+          (go-ctx-extend ctx nm
+            (list :ty-param nm constraint))
+          (rest names) constraint)))))