go: types.sx — func-decl + stmt-level dispatch + 7 tests [nothing]

Phase 3 cont. Adds:

  * go-check-func-decl — binds the function in the outer ctx (recursive
    self-reference will work once call-checking lands), extends the
    body's ctx with each :field param group via go-ctx-extend-field
    (the binding-group shape's *third* consumer in the type checker;
    five total across parser+typer when counted with struct fields,
    var-decls, const-decls, func params, method receivers).
  * go-check-stmt — dispatches on :return / :assign / :var-decl /
    :const-decl / :short-decl / :type-decl / :block; falls back to
    go-synth for expression statements.
  * go-check-block — threads ctx through stmts so that decls inside
    the block extend the ctx for subsequent stmts.
  * go-check-return-list — each return expr assignable to the
    corresponding declared result type; mismatch counts are typed.
  * go-check-assign / go-check-assign-pairs — RHS assignable to LHS
    synthesised type, count mismatch typed.
  * Helpers: go-decl-params-to-ty-list (flattens :field NAMES TYPE to
    a flat list of N types), go-extend-with-params (folds extend-field
    over a param-group list), go-repeat-ty.

Coverage tests:
  func empty() {}                                          → ok
  func add(x, y int) int { return x + y }                  → ok
  func bad() int { return "hi" }                           → typed error
  func sig(x int) int                                      → signature-only binds
  func sumsq(x, y int) int { return x*x + y*y }            → params visible
  func two() int { var x int = 1; var y int = 2;           → nested decl
                   return x + y }
  func g() int { var x int; x = 5; return x }              → assign verified

types 47/47, total 352/352.

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

lib/go/tests/types.sx

@@ -264,6 +264,68 @@
     (list (go-ctx-lookup ctx "a") (go-ctx-lookup ctx "b")))
   (list (list :ty-name "int") (list :ty-name "int")))
 
+(go-types-test
+  "fdecl: func empty() — binds empty to func type"
+  (go-ctx-lookup
+    (go-check-decl go-ctx-empty (go-parse "func empty() {}"))
+    "empty")
+  (list :ty-func (list) (list)))
+
+(go-types-test
+  "fdecl: func add(x, y int) int { return x + y } — ok"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func add(x, y int) int { return x + y }"))
+    "add")
+  (list
+    :ty-func (list (list :ty-name "int") (list :ty-name "int"))
+    (list (list :ty-name "int"))))
+
+(go-types-test
+  "fdecl: func bad() int { return \"hi\" } — type error"
+  (go-check-decl go-ctx-empty (go-parse "func bad() int { return \"hi\" }"))
+  (list
+    :type-error :mismatch
+    (list :ty-name "int")
+    (list :ty-untyped-string)))
+
+(go-types-test
+  "fdecl: signature-only (no body)"
+  (go-ctx-lookup
+    (go-check-decl go-ctx-empty (go-parse "func sig(x int) int"))
+    "sig")
+  (list :ty-func (list (list :ty-name "int")) (list (list :ty-name "int"))))
+
+(go-types-test
+  "fdecl: param-bound — body sees x and y"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func sumsq(x, y int) int { return x*x + y*y }"))
+    "sumsq")
+  (list :ty-func
+    (list (list :ty-name "int") (list :ty-name "int"))
+    (list (list :ty-name "int"))))
+
+(go-types-test
+  "fdecl: nested decl in body extends ctx for later stmts"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func two() int { var x int = 1; var y int = 2; return x + y }"))
+    "two")
+  (list :ty-func (list) (list (list :ty-name "int"))))
+
+(go-types-test
+  "fdecl: assign inside body — type-checks RHS vs LHS"
+  (go-ctx-lookup
+    (go-check-decl
+      go-ctx-empty
+      (go-parse "func g() int { var x int; x = 5; return x }"))
+    "g")
+  (list :ty-func (list) (list (list :ty-name "int"))))
+
 (define
   go-types-test-summary
   (str "types " go-types-test-pass "/" go-types-test-count))