go: parse.sx scaffold — primary expressions + Go precedence table + 17 tests [consumes-pratt consumes-ast]

Starts Phase 2. lib/go/parse.sx defines:
  * go-precedence-table — Go's five operator-precedence levels in the
    (NAME PREC ASSOC) entry shape from lib/guest/pratt.sx, ready for the
    binary-operator iteration to consume via pratt-op-lookup.
  * go-parse(src) — tokenises and parses ONE primary expression: int,
    float, imag, string, rune literals become (ast-literal VALUE);
    identifiers become (ast-var NAME). Built directly on lib/guest/ast.sx
    constructors — no intermediate AST shape.

Conformance.sh extended to load lib/guest/{ast,pratt}.sx and run the
new parse suite. Scoreboard cleanup: drop the "pending" parse row since
the suite is now real.

parse 17/17 (lex still 129/129). Total 146/146.

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

lib/go/parse.sx

@@ -0,0 +1,66 @@
+;; lib/go/parse.sx — Go parser. Tokenises via go-tokenize (lib/go/lex.sx),
+;; builds canonical AST nodes per lib/guest/ast.sx, and uses the operator
+;; entry shape from lib/guest/pratt.sx for precedence climbing (Pratt).
+;;
+;; First slice: primary expressions only —
+;;   int / float / imag / string / rune literal → (ast-literal VALUE)
+;;   identifier                                 → (ast-var NAME)
+;;
+;; Subsequent slices add binary operators (via gp-precedence-table +
+;; pratt-op-lookup), function calls, type expressions, declarations,
+;; and statements.
+;;
+;; All scanner locals are gp- prefixed (mirrors lib/go/lex.sx's gl- prefix):
+;; SX host primitives silently shadow guest-language defines.
+
+(define
+  go-precedence-table
+  (list
+    (list "*" 5 :left)
+    (list "/" 5 :left)
+    (list "%" 5 :left)
+    (list "<<" 5 :left)
+    (list ">>" 5 :left)
+    (list "&" 5 :left)
+    (list "&^" 5 :left)
+    (list "+" 4 :left)
+    (list "-" 4 :left)
+    (list "|" 4 :left)
+    (list "^" 4 :left)
+    (list "==" 3 :left)
+    (list "!=" 3 :left)
+    (list "<" 3 :left)
+    (list "<=" 3 :left)
+    (list ">" 3 :left)
+    (list ">=" 3 :left)
+    (list "&&" 2 :left)
+    (list "||" 1 :left)))
+
+(define
+  go-parse
+  (fn
+    (src)
+    (let
+      ((gp-tokens (go-tokenize src)) (gp-idx 0))
+      (define gp-cur (fn () (nth gp-tokens gp-idx)))
+      (define gp-advance! (fn () (set! gp-idx (+ gp-idx 1))))
+      (define gp-tok-type (fn () (get (gp-cur) :type)))
+      (define gp-tok-value (fn () (get (gp-cur) :value)))
+      (define
+        gp-parse-primary
+        (fn
+          ()
+          (let
+            ((ty (gp-tok-type)) (v (gp-tok-value)))
+            (cond
+              (or
+                (= ty "int")
+                (= ty "float")
+                (= ty "imag")
+                (= ty "string")
+                (= ty "rune"))
+              (do (gp-advance!) (ast-literal v))
+              (= ty "ident")
+              (do (gp-advance!) (ast-var v))
+              :else nil))))
+      (gp-parse-primary))))