feat(selfhost): AST producer — let-else, if-let, protocols, tuples → (measuring)

- let-else statement (`let Some(x) = e else { … }`) with the reference's off-by-one
  else-block (parse_block(open+1)) reproduced for byte parity.
- if-let (`if let P = e { } else { }`) desugars to a two-arm match (pattern + wildcard).
- Protocols fully supported: methods emit in source order as top-level functions with
  the parse_protocol_decl transforms (Protocol.method name, public, injected
  Self:Managed generic); `protocol <name>` (section 3) and `protocol-impl … / mapping`
  (section 4) emit in later passes matching ast_oracle_dump ordering. impls parsed
  from `impl P for T { m = target }`; native-modules still deferred.
- Tuples: types `(A,B)` → __TupleN + args; expressions `(a,b)` → __TupleN(item0:…)
  call; let-destructure `let (a,_,c) = …` → destructure=a,_,c.

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

Author: olwang

selfhost/astdump.rss

@@ -0,0 +1,45 @@
+struct ToolRequest {
+    name: String
+}
+
+fn dispatch(name: read String) -> String {
+    match name {
+        "read_file" => { return "read" }
+        "write_file" => { return "write" }
+        _ => { return "unknown" }
+    }
+}
+
+fn bool_label(value: Bool) -> String {
+    return match value {
+        true => { "yes" }
+        false => { "no" }
+    }
+}
+
+fn int_label(value: Int) -> String {
+    return match value {
+        0 => { "zero" }
+        1 => { "one" }
+        _ => { "many" }
+    }
+}
+
+fn maybe_tool(enabled: Bool) -> Option<ToolRequest> {
+    if enabled {
+        return Some(ToolRequest(name: "read_file"))
+    }
+    return None
+}
+
+fn run(enabled: Bool) -> String {
+    if let Some(tool) = maybe_tool(enabled: enabled) {
+        return dispatch(name: read tool.name)
+    }
+    return "none"
+}
+
+fn main() -> Unit {
+    let result = run(enabled: true)
+    Log.write(message: read result)
+}

selfhost/samples/ast/x_if_let.rss

@@ -0,0 +1,10 @@
+fn unwrap_option(value: read Option<String>) -> String {
+    let Some(inner) = value else {
+        return "default"
+    }
+    return inner
+}
+
+fn main() -> Unit {
+    let result = unwrap_option(value: read Some("hello"))
+}

selfhost/samples/ast/x_let_else.rss

@@ -0,0 +1,23 @@
+features: local
+
+protocol Formatter {
+    fn format(self: read Self) -> fresh String
+}
+
+struct Point {
+    x: Int
+    y: Int
+}
+
+fn Point.format(self: read Point) -> fresh String {
+    return String.concat(left: read "point", right: read "!")
+}
+
+impl Formatter for Point {
+    format = Point.format
+}
+
+fn print_item<F: Formatter>(item: read F) -> Unit {
+    let msg = Formatter.format(self: read item)
+    Log.write(message: read msg)
+}

selfhost/samples/ast/x_protocol_basic_impl.rss

@@ -0,0 +1,8 @@
+// expect: RS0015
+protocol Writer {
+    fn write(self: mut Self, message: read String) -> Unit
+        effects(retains(message))
+    {
+        Log.write(message: read message)
+    }
+}

selfhost/samples/ast/x_protocol_default_method_body.rss

@@ -0,0 +1,34 @@
+features: local
+
+protocol Writer {
+    fn write(self: mut Self, message: read String) -> Unit
+        effects(retains(message))
+
+    fn flush(self: mut Self) -> Unit
+}
+
+class BufferWriter {
+    buffer: List<String>
+}
+
+fn BufferWriter.write(self: mut BufferWriter, message: read String) -> Unit
+    effects(retains(message))
+{
+    List.push<String>(list: mut self.buffer, value: read message)
+}
+
+fn BufferWriter.flush(self: mut BufferWriter) -> Unit {
+    let count = List.len<String>(list: read self.buffer)
+    Log.write(message: read "flushed")
+}
+
+impl Writer for BufferWriter {
+    write = BufferWriter.write
+    flush = BufferWriter.flush
+}
+
+fn write_line<W: Writer>(writer: mut W, message: read String) -> Unit
+    effects(retains(message))
+{
+    Writer.write(self: mut writer, message: read message)
+}

selfhost/samples/ast/x_protocol_multiple_methods.rss

@@ -0,0 +1,22 @@
+// expect: RS0206
+features: local
+
+protocol Formatter {
+    fn format(self: read Self) -> fresh String
+}
+
+struct Report {
+    title: String
+}
+
+fn Report.format(self: read Report) -> fresh String {
+    return String.concat(left: read "report:", right: read self.title)
+}
+
+impl Formatter for Report {
+    format = Report.format
+}
+
+fn display(report: read Report) -> fresh String {
+    return read report.format()
+}

selfhost/samples/ast/x_receiver_call_ambiguous_method.rss

@@ -0,0 +1,23 @@
+// Tuples desugar to synthetic `__TupleN` generic structs: literals `(a, b)`,
+// types `(Int, String)`, `.itemN` field access, tuple patterns in `match`, and
+// `let (a, b) = ...` destructuring (with `_` to skip an element).
+fn classify(p: read (Int, String)) -> fresh String {
+    match read p {
+        (0, name) => { return String.concat(left: read "zero-", right: read name) }
+        (n, name) => { return String.concat(left: read String.from_int(value: n), right: read name) }
+    }
+}
+
+fn sum_first_two(triple: read (Int, Int, Int)) -> Int {
+    return triple.item0 + triple.item1
+}
+
+fn main() -> Unit {
+    let pair: (Int, String) = (7, "b")
+    Log.write(message: read classify(p: read pair))
+    let counts: (Int, Int, Int) = (1, 2, 3)
+    Log.write(message: read String.from_int(value: sum_first_two(triple: read counts)))
+    let (first, _, third) = (1, 2, 3)
+    Log.write(message: read String.from_int(value: first + third))
+    return Unit
+}