go: parse.sx — function calls + member access + 12 tests [consumes-ast proposes-ast]

Adds postfix expression forms per Go spec:
  f()  f(x)  f(x, y, z)       — function calls
  x.y  x.y.z  obj.method(x)   — selector / member access

gp-parse-postfix sits between gp-parse-unary and gp-parse-primary,
so calls and selectors bind tighter than any unary prefix — `-f(x)`
parses as `-(f(x))`, not `(-f)(x)`. Postfix is left-associative
(`x.y.z` = `(x.y).z`), so the loop iterates rather than recurses
on the LHS.

AST shapes:
  Call:     (ast-app FN ARGS)              — canonical
  Selector: (list :select OBJ "field")     — Go-specific tag

The selector shape is a kit gap — lib/guest/ast.sx ships ast-app but
no ast-select, despite `obj.field` being universal across Go, Rust,
Swift, TS, JS, Python, Ruby, Java, C#. Logged in Blockers; tagging
[proposes-ast]. Worth promoting on the next nominally-typed guest.

parse 49/49, total 178/178.

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

lib/go/parse.sx

@@ -64,6 +64,72 @@
               (= ty "ident")
               (do (gp-advance!) (ast-var v))
               :else nil))))
+      (define
+        gp-parse-call-args
+        ;; Parse comma-separated args inside (...). Caller has already
+        ;; consumed the opening "(". Consumes the closing ")".
+        ;; Returns a list of argument AST nodes.
+        (fn
+          ()
+          (let ((args (list)))
+            (cond
+              (and (= (gp-tok-type) "op") (= (gp-tok-value) ")"))
+              (do (gp-advance!) args)
+              :else
+              (do
+                (let ((first (gp-parse-expr 1)))
+                  (when (not (= first nil)) (append! args first)))
+                (define
+                  gp-args-rest
+                  (fn
+                    ()
+                    (cond
+                      (and (= (gp-tok-type) "op") (= (gp-tok-value) ","))
+                      (do
+                        (gp-advance!)
+                        (let ((arg (gp-parse-expr 1)))
+                          (when (not (= arg nil)) (append! args arg)))
+                        (gp-args-rest))
+                      (and (= (gp-tok-type) "op") (= (gp-tok-value) ")"))
+                      (gp-advance!)
+                      :else nil)))
+                (gp-args-rest)
+                args)))))
+      (define
+        gp-parse-postfix
+        ;; Left-associative postfix loop on top of gp-parse-primary:
+        ;;   x.field    →  (list :select x "field")  — Go-specific node,
+        ;;                 no kit shape covers selector access
+        ;;   f(args...) →  (ast-app f args)          — canonical
+        (fn
+          ()
+          (let ((base (gp-parse-primary)))
+            (gp-postfix-loop base))))
+      (define
+        gp-postfix-loop
+        (fn
+          (base)
+          (cond
+            (= base nil) nil
+            :else
+            (let ((tok (gp-cur)))
+              (cond
+                (and (= (get tok :type) "op") (= (get tok :value) "."))
+                (do
+                  (gp-advance!)
+                  (let ((field-tok (gp-cur)))
+                    (cond
+                      (= (get field-tok :type) "ident")
+                      (do
+                        (gp-advance!)
+                        (gp-postfix-loop
+                          (list :select base (get field-tok :value))))
+                      :else base)))
+                (and (= (get tok :type) "op") (= (get tok :value) "("))
+                (do
+                  (gp-advance!)
+                  (gp-postfix-loop (ast-app base (gp-parse-call-args))))
+                :else base)))))
       (define
         gp-unary-ops
         ;; Go spec § Operators: prefix unary, all higher precedence than
@@ -84,7 +150,7 @@
                   (cond
                     (= operand nil) nil
                     :else (ast-app (ast-var (get tok :value)) (list operand)))))
-              :else (gp-parse-primary)))))
+              :else (gp-parse-postfix)))))
       (define
         gp-parse-expr
         (fn