go: parse.sx — interface type expressions + 8 tests; type expressions DONE [nothing]

Adds Go interface type expressions:
  interface {}                              →  empty
  interface { Close() }                     →  no-param method
  interface { String() string }             →  with single return
  interface { Read([]byte) (int, error) }   →  multi-return method
  interface { Stringer }                    →  embedded named iface
  interface { io.Reader }                   →  qualified embedded
  interface { io.Reader; Close() error }    →  mixed

gp-parse-interface-elems walks elements tolerating ASI semis. Each
element is either:
  (list :method NAME PARAMS RESULTS)
  (list :embed TYPE)

Method params/results reuse gp-parse-func-type-params/results — the
shape is identical to a free-standing func type. Go 1.18+ type sets
(interface { ~int | ~float64 }) are deferred until the generics
sub-deliverable.

With this, the full Phase 2 **type expressions** sub-deliverable is
complete (pending only field tags, struct/iface embeds details,
variadic, named func params, generics — all flagged later).

parse 106/106, total 235/235.

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

lib/go/parse.sx

@@ -95,6 +95,58 @@
                       :else nil)))
                 (gp-args-rest)
                 args)))))
+      (define
+        gp-parse-interface-elems
+        ;; Caller positioned BEFORE '{'. Parses elements until '}'.
+        ;; Two element shapes:
+        ;;   M(params) [results]   →  (list :method "M" PARAMS RESULTS)
+        ;;   T  or  pkg.T          →  (list :embed TYPE)
+        ;; Type sets (Go 1.18+: ~int | ~float64) deferred.
+        (fn
+          ()
+          (when (and (= (gp-tok-type) "op") (= (gp-tok-value) "{"))
+            (gp-advance!))
+          (let ((elems (list)))
+            (define
+              gp-iface-loop
+              (fn
+                ()
+                (cond
+                  (= (gp-tok-type) "semi")
+                  (do (gp-advance!) (gp-iface-loop))
+                  (and (= (gp-tok-type) "op") (= (gp-tok-value) "}"))
+                  (gp-advance!)
+                  (= (gp-tok-type) "ident")
+                  (do
+                    (let ((name (gp-tok-value)))
+                      (gp-advance!)
+                      (cond
+                        (and (= (gp-tok-type) "op")
+                             (= (gp-tok-value) "("))
+                        (let ((params (gp-parse-func-type-params)))
+                          (let ((results (gp-parse-func-type-results)))
+                            (append! elems
+                              (list :method name params results))))
+                        (and (= (gp-tok-type) "op")
+                             (= (gp-tok-value) "."))
+                        (do
+                          (gp-advance!)
+                          (cond
+                            (= (gp-tok-type) "ident")
+                            (let ((sel-name (gp-tok-value)))
+                              (gp-advance!)
+                              (append! elems
+                                (list :embed
+                                  (list :ty-sel name sel-name))))
+                            :else
+                            (append! elems
+                              (list :embed (list :ty-name name)))))
+                        :else
+                        (append! elems (list :embed (list :ty-name name)))))
+                    (gp-iface-loop))
+                  :else nil)))
+            (gp-iface-loop)
+            elems)))
       (define
         gp-parse-struct-fields
         ;; Caller positioned BEFORE '{'. Parses fields until '}'.
@@ -251,6 +303,10 @@
             (do
               (gp-advance!)
               (list :ty-struct (gp-parse-struct-fields)))
+            (and (= (gp-tok-type) "keyword") (= (gp-tok-value) "interface"))
+            (do
+              (gp-advance!)
+              (list :ty-interface (gp-parse-interface-elems)))
             (= (gp-tok-type) "ident")
             (let ((name (gp-tok-value)))
               (gp-advance!)