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/tests/lex.sx

@@ -74,7 +74,7 @@
 (go-test "int: bigger" (tok-values "123456") (list "123456" "\n" nil))
 (go-test "int: type" (tok-types "42") (list "int" "semi" "eof"))
 
-;; ── integer literals — prefixed + underscores (Go spec § Integer literals)
+;; ── integer literals — prefixed + underscores ─────────────────────
 (go-test "int: hex lower" (tok-values "0x1f") (list "0x1f" "\n" nil))
 (go-test "int: hex upper-x" (tok-values "0X1F") (list "0X1F" "\n" nil))
 (go-test
@@ -105,6 +105,43 @@
   (tok-types "0xFF + 1")
   (list "int" "op" "int" "semi" "eof"))
 
+;; ── float literals (Go spec § Floating-point literals) ────────────
+(go-test "float: simple" (tok-values "3.14") (list "3.14" "\n" nil))
+(go-test "float: trailing dot" (tok-values "1.") (list "1." "\n" nil))
+(go-test "float: leading dot" (tok-values ".5") (list ".5" "\n" nil))
+(go-test "float: exp lower" (tok-values "1e10") (list "1e10" "\n" nil))
+(go-test "float: exp upper" (tok-values "1E5") (list "1E5" "\n" nil))
+(go-test "float: exp negative" (tok-values "1.5e-3") (list "1.5e-3" "\n" nil))
+(go-test "float: exp positive" (tok-values "2.0e+2") (list "2.0e+2" "\n" nil))
+(go-test "float: zero" (tok-values "0.0") (list "0.0" "\n" nil))
+(go-test "float: dot-only-exp" (tok-values ".5e2") (list ".5e2" "\n" nil))
+(go-test "float: underscore" (tok-values "1_000.5") (list "1_000.5" "\n" nil))
+(go-test "float: type" (tok-types "3.14") (list "float" "semi" "eof"))
+(go-test
+  "float: trailing dot type"
+  (tok-types "1.")
+  (list "float" "semi" "eof"))
+(go-test
+  "float: exp-only type"
+  (tok-types "1e10")
+  (list "float" "semi" "eof"))
+(go-test
+  "float: then +"
+  (tok-types "3.14 + 0.1")
+  (list "float" "op" "float" "semi" "eof"))
+(go-test
+  "float: greedy 1.method"
+  (tok-types "1.method")
+  (list "float" "ident" "semi" "eof"))
+
+;; ── imaginary literals (Go spec § Imaginary literals) ─────────────
+(go-test "imag: int i" (tok-values "2i") (list "2i" "\n" nil))
+(go-test "imag: float i" (tok-values "3.14i") (list "3.14i" "\n" nil))
+(go-test "imag: exp i" (tok-values "1e2i") (list "1e2i" "\n" nil))
+(go-test "imag: int-i type" (tok-types "2i") (list "imag" "semi" "eof"))
+(go-test "imag: float-i type" (tok-types "3.14i") (list "imag" "semi" "eof"))
+(go-test "imag: ASI at newline" (tok-types "1i\n") (list "imag" "semi" "eof"))
+
 ;; ── string literals ───────────────────────────────────────────────
 (go-test "string: empty" (tok-values "\"\"") (list "" "\n" nil))
 (go-test "string: hello" (tok-values "\"hello\"") (list "hello" "\n" nil))
@@ -170,6 +207,7 @@
   (tok-types "x\ny")
   (list "ident" "semi" "ident" "semi" "eof"))
 (go-test "ASI: after int" (tok-types "42\n") (list "int" "semi" "eof"))
+(go-test "ASI: after float" (tok-types "3.14\n") (list "float" "semi" "eof"))
 (go-test
   "ASI: after string"
   (tok-types "\"hi\"\n")