go: lex.sx — hex/octal/binary integer literals + underscores, +14 tests [consumes-lex]

Adds prefixed integer forms per Go spec § Integer literals:
0x.. / 0X.. (hex), 0b.. / 0B.. (binary), 0o.. / 0O.. (octal),
legacy 0123 octal also accepted. Underscores allowed between digits
in any run; lexer is permissive (parser/types phase can enforce
strict placement).

Dispatch lives in gl-read-number! against the first 1-2 chars;
hex digit run consumes lex-hex-digit? from lib/guest/lex.sx. Octal
and binary use local gl-oct-digit?/gl-bin-digit? — narrow enough
that promoting them to the kit is premature.

lex 92/92.

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

lib/go/lex.sx

@@ -6,7 +6,8 @@
 ;; Types:
 ;;   "ident"   — identifiers (foo, _bar, mixedCase)
 ;;   "keyword" — one of the 25 Go keywords
-;;   "int"     — integer literals (decimal only this iteration)
+;;   "int"     — integer literals (decimal, 0x.. hex, 0b.. binary, 0o.. octal,
+;;               legacy 0123 octal; underscores between digits allowed)
 ;;   "string"  — interpreted string literals "..."
 ;;   "rune"    — rune literals 'x' (single char + simple escapes)
 ;;   "op"      — operators & punctuation; :value is the literal text
@@ -100,6 +101,10 @@
         (fn
           (at)
           (when (go-asi-trigger? (gl-last)) (gl-emit! "semi" "\n" at))))
+      (define
+        gl-oct-digit?
+        (fn (c) (and (not (= c nil)) (>= c "0") (<= c "7"))))
+      (define gl-bin-digit? (fn (c) (or (= c "0") (= c "1"))))
       (define
         gl-skip-line!
         (fn
@@ -131,13 +136,37 @@
             (gl-read-ident! start))
           (slice src start pos)))
       (define
-        gl-read-digits!
+        gl-read-digit-run!
+        (fn
+          (digit?)
+          (when
+            (and (< pos src-len) (or (digit? (gl-cur)) (= (gl-cur) "_")))
+            (gl-advance! 1)
+            (gl-read-digit-run! digit?))))
+      (define
+        gl-read-number!
         (fn
           ()
-          (when
-            (and (< pos src-len) (lex-digit? (gl-cur)))
-            (gl-advance! 1)
-            (gl-read-digits!))))
+          (cond
+            (and
+              (= (gl-cur) "0")
+              (or
+                (= (gl-peek 1) "x")
+                (= (gl-peek 1) "X")))
+            (do (gl-advance! 2) (gl-read-digit-run! lex-hex-digit?))
+            (and
+              (= (gl-cur) "0")
+              (or
+                (= (gl-peek 1) "b")
+                (= (gl-peek 1) "B")))
+            (do (gl-advance! 2) (gl-read-digit-run! gl-bin-digit?))
+            (and
+              (= (gl-cur) "0")
+              (or
+                (= (gl-peek 1) "o")
+                (= (gl-peek 1) "O")))
+            (do (gl-advance! 2) (gl-read-digit-run! gl-oct-digit?))
+            :else (gl-read-digit-run! lex-digit?))))
       (define
         gl-read-string!
         (fn
@@ -343,7 +372,7 @@
             (do
               (let
                 ((start pos))
-                (gl-read-digits!)
+                (gl-read-number!)
                 (gl-emit! "int" (slice src start pos) start))
               (gl-scan!))
             (= (gl-cur) "\"")