fix(selfhost): AST producer — type-annotated let value split → 339/579

emit_let used top_assign to find the `=`, whose `>=`/`<=`/`==` guard wrongly
skipped the assignment `=` immediately after a generic close `>` — so
`let x: Option<Int> = Some(...)` dropped its entire value subtree. Switched the let
to the reference's rule (parse_let_stmt): the value split is simply the FIRST `=`
after the name (a let's name/annotation never contains `=`, so no guard is needed).
top_assign is kept for assignment statements, which do need the comparison guard.

Corpus reach: 331 -> 339 / 579 byte-exact, still 0 run-failures. Floor -> 339.
New sample let_typed.rss (incl. `let flag: Bool = seed >= 0`).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/selfhost_parity.rs

@@ -1522,7 +1522,7 @@ const AST_SAMPLE_MIN: usize = 6;
 /// Floor for `ast_parity_corpus` — the number of corpus files whose rss AST dump
 /// already matches the oracle byte-for-byte. Ratchets up as the producer's
 /// coverage grows; a drop signals a regression. (Full parity = files.len().)
-const AST_CORPUS_PARITY_FLOOR: usize = 331;
+const AST_CORPUS_PARITY_FLOOR: usize = 339;
 
 /// Step-2 measurement gate (ignored by default): how many corpus files the rss
 /// producer reproduces byte-for-byte. Not full parity yet — this ratchets a floor

selfhost/astdump.rss

@@ -1049,6 +1049,17 @@ fn is_cont_op(toks: read List<Tok>, i: read Int) -> Bool {
 }
 
 // First top-level standalone `=` (assignment, not == != <= >=) in [start, end), or -1.
+// First `=` symbol token in [start, end), or -1 (used for let value split;
+// `=>` is a distinct FatArrow token, not matched).
+fn first_eq(toks: read List<Tok>, start: read Int, end: read Int) -> Int {
+    let mut i = start
+    while i < end {
+        if at_symbol(toks: read toks, i: read i, code: read SYM_EQ) { return i }
+        i = i + 1
+    }
+    return -1
+}
+
 fn top_assign(toks: read List<Tok>, start: read Int, end: read Int) -> Int {
     let mut depth = 0
     let mut i = start
@@ -1172,8 +1183,11 @@ fn emit_let(toks: read List<Tok>, start: read Int, limit: read Int, d: read Int)
     let g = String.concat(left: read f, right: read boolstr(b: read isMut))
     let h = String.concat(left: read g, right: read " async=false")
     emit(depth: read d, s: read h)
-    // Optional type annotation.
-    let asg = top_assign(toks: read toks, start: read j, end: read e)
+    // Value split is the FIRST `=` after the name (matching parse_let_stmt): a
+    // let's name/annotation never contains `=`, so no `>=`/`==` guard is needed —
+    // and top_assign's guard would wrongly skip the `=` after a generic `>`
+    // (`let x: Option<Int> = …`).
+    let asg = first_eq(toks: read toks, start: read j, end: read e)
     if at_symbol(toks: read toks, i: read j, code: read SYM_COLON) {
         emit_type_ref(toks: read toks, i: read (j + 1), tag: read "type", eff: read "", d: read (d + 1))
     }

selfhost/samples/ast/let_typed.rss

@@ -0,0 +1,6 @@
+fn hot(seed: Int) -> Int {
+    let value: Option<Int> = Some(seed)
+    let names: List<String> = List<String>.new()
+    let flag: Bool = seed >= 0
+    return 0
+}