go: lex.sx — decimal float + imaginary literals + 22 tests [consumes-lex]

Adds Go float and imaginary literal forms per Go spec § Floating-point
literals and § Imaginary literals:
  3.14   .5   1.   1e10   1.5e-3   2.0e+2   1E5    (floats)
  2i     3.14i   1e2i                              (imag)

gl-read-number! returns one of "int" / "float" / "imag"; gl-finish-number!
factors out the post-mantissa exponent + 'i' suffix logic so the int /
float / leading-dot-float paths all share it. scan! adds a .<digit>
branch ahead of the operator matcher so '.5' tokenises as float.

ASI trigger list extended to include float + imag (Go spec § Semicolons:
all literal types trigger).

Greedy-grammar pin (a single test '1.method' lexes as float ident),
since the Go spec says the '.' after a digit always belongs to the
number, never to a following identifier.

Hex floats (0x1.fp0) deferred — not commonly used.

lex 114/114.

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

lib/go/lex.sx

@@ -8,6 +8,8 @@
 ;;   "keyword" — one of the 25 Go keywords
 ;;   "int"     — integer literals (decimal, 0x.. hex, 0b.. binary, 0o.. octal,
 ;;               legacy 0123 octal; underscores between digits allowed)
+;;   "float"   — decimal float literals (3.14, .5, 1., 1e10, 1.5e-3, 1E5)
+;;   "imag"    — imaginary literals (2i, 3.14i, 1e2i)
 ;;   "string"  — interpreted string literals "..."
 ;;   "rune"    — rune literals 'x' (single char + simple escapes)
 ;;   "op"      — operators & punctuation; :value is the literal text
@@ -16,7 +18,7 @@
 ;;
 ;; ASI (Go spec § Semicolons): a newline (or EOF, or a block comment
 ;; containing a newline) emits a ";semi" if the previous emitted token's
-;; type is ident/int/string/rune, or its value is one of
+;; type is ident/int/float/imag/string/rune, or its value is one of
 ;;   {break, continue, fallthrough, return, ++, --, ), ], }}.
 ;;
 ;; All scanner locals are gl- prefixed: SX host primitives (peek/emit/etc.)
@@ -57,6 +59,8 @@
 
 (define go-asi-ops (list "++" "--" ")" "]" "}"))
 
+(define go-asi-lit-types (list "ident" "int" "float" "imag" "string" "rune"))
+
 (define
   go-asi-trigger?
   (fn
@@ -67,10 +71,7 @@
       (let
         ((ty (get tok :type)) (v (get tok :value)))
         (or
-          (= ty "ident")
-          (= ty "int")
-          (= ty "string")
-          (= ty "rune")
+          (some (fn (lt) (= lt ty)) go-asi-lit-types)
           (and (= ty "keyword") (some (fn (k) (= k v)) go-asi-keywords))
           (and (= ty "op") (some (fn (o) (= o v)) go-asi-ops)))))))
 
@@ -143,30 +144,70 @@
             (and (< pos src-len) (or (digit? (gl-cur)) (= (gl-cur) "_")))
             (gl-advance! 1)
             (gl-read-digit-run! digit?))))
+      (define
+        gl-finish-number!
+        (fn
+          (has-fraction?)
+          (let
+            ((typ (if has-fraction? "float" "int")))
+            (when
+              (or (= (gl-cur) "e") (= (gl-cur) "E"))
+              (gl-advance! 1)
+              (when
+                (or (= (gl-cur) "+") (= (gl-cur) "-"))
+                (gl-advance! 1))
+              (gl-read-digit-run! lex-digit?)
+              (set! typ "float"))
+            (cond
+              (= (gl-cur) "i")
+              (do (gl-advance! 1) "imag")
+              :else typ))))
       (define
         gl-read-number!
         (fn
           ()
           (cond
+            (and (= (gl-cur) ".") (lex-digit? (gl-peek 1)))
+            (do
+              (gl-advance! 1)
+              (gl-read-digit-run! lex-digit?)
+              (gl-finish-number! true))
             (and
               (= (gl-cur) "0")
               (or
                 (= (gl-peek 1) "x")
                 (= (gl-peek 1) "X")))
-            (do (gl-advance! 2) (gl-read-digit-run! lex-hex-digit?))
+            (do
+              (gl-advance! 2)
+              (gl-read-digit-run! lex-hex-digit?)
+              "int")
             (and
               (= (gl-cur) "0")
               (or
                 (= (gl-peek 1) "b")
                 (= (gl-peek 1) "B")))
-            (do (gl-advance! 2) (gl-read-digit-run! gl-bin-digit?))
+            (do
+              (gl-advance! 2)
+              (gl-read-digit-run! gl-bin-digit?)
+              "int")
             (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?))))
+            (do
+              (gl-advance! 2)
+              (gl-read-digit-run! gl-oct-digit?)
+              "int")
+            :else (do
+              (gl-read-digit-run! lex-digit?)
+              (cond
+                (and (= (gl-cur) ".") (not (= (gl-peek 1) ".")))
+                (do
+                  (gl-advance! 1)
+                  (gl-read-digit-run! lex-digit?)
+                  (gl-finish-number! true))
+                :else (gl-finish-number! false))))))
       (define
         gl-read-string!
         (fn
@@ -371,9 +412,14 @@
             (lex-digit? (gl-cur))
             (do
               (let
-                ((start pos))
-                (gl-read-number!)
-                (gl-emit! "int" (slice src start pos) start))
+                ((start pos) (typ (gl-read-number!)))
+                (gl-emit! typ (slice src start pos) start))
+              (gl-scan!))
+            (and (= (gl-cur) ".") (lex-digit? (gl-peek 1)))
+            (do
+              (let
+                ((start pos) (typ (gl-read-number!)))
+                (gl-emit! typ (slice src start pos) start))
               (gl-scan!))
             (= (gl-cur) "\"")
             (let