Phase 2 abgeschlossen: Bytecode, TBVM, Runtime-Scheibe, tbc run

- Sema zum Lowering-Pass umgebaut: typisiertes HIR (Slots, explizite
  Konvertierungsknoten) als Codegen-Eingabe; BYREF verlangt exakten Typ
- Bytecode-Feindesign umgesetzt: monomorpher Opcode-Satz,
  .tbc-Container (Formatversion 1) mit eigenem Writer/Reader
- Codegenerator HIR -> Bytecode (Fixup-Listen, keine globalen Passes)
- TBVM-Interpreter: Kontrollfluss, GOSUB-Stack je Frame, BYREF/BYVAL,
  STATIC, DEF FN, DATA/READ/RESTORE, ON [LOCAL] ERROR/RESUME/ERR/ERL,
  Breakpoints/Einzelschritt/Inspektion, STOP fortsetzbar
- Runtime-Scheibe: Host-Trait (Konsole/Capture), Builtin-Tabelle,
  Konvertierungsmatrix, PRINT-Formatierung/Druckzonen, Stringfunktionen
- tbc run/build/check mit Exit-Codes nach Entscheidung D6
- Korpus-Harness (byte-genauer Vergleich) + 3 neue Korpusdateien
  (konvertierung, fehlerbehandlung, byref); 137 Tests gruen
- Benchmarks: Einzelmodul 1,2 ms / Projekt 49.760 Zeilen 124 ms
  (Budgets eingehalten), VM ~5 Mio Schleifeniterationen/s
- Doku fortgeschrieben (tbvm-design, sprachreferenz, PLAN);
  verlagerte Punkte als explizite Aufgaben in Phase 3
- OpenSpec-Change phase-2-bytecode-vm (27/27 Tasks)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/tb-runtime/src/host.rs

@@ -0,0 +1,92 @@
+//! `Host`-Abstraktion für Konsolen-E/A (Design-Entscheidung D3):
+//! Alle Konsolenwirkungen der VM laufen über dieses Trait. Host-Aufrufe
+//! dürfen blockieren; die Abbruchprüfung (Strg+Untbr) obliegt dem Host.
+
+use std::collections::VecDeque;
+use std::io::{BufRead, Write as _};
+
+pub trait Host {
+    /// Text ausgeben (ohne implizite Zeilenumbrüche).
+    fn write(&mut self, s: &str);
+    /// Eine Eingabezeile lesen (ohne Zeilenende); `None` = Eingabeende.
+    fn read_line(&mut self) -> Option<String>;
+    /// Abbruchwunsch (Strg+Untbr)? Wird an Anweisungsgrenzen geprüft.
+    fn interrupted(&mut self) -> bool {
+        false
+    }
+    /// `SLEEP` — blockierend im Host.
+    fn sleep(&mut self, _secs: f64) {}
+}
+
+/// Konsolen-Host für `tbc run`: stdout/stdin.
+#[derive(Default)]
+pub struct ConsoleHost;
+
+impl Host for ConsoleHost {
+    fn write(&mut self, s: &str) {
+        let mut out = std::io::stdout().lock();
+        let _ = out.write_all(s.as_bytes());
+        let _ = out.flush();
+    }
+
+    fn read_line(&mut self) -> Option<String> {
+        let mut line = String::new();
+        match std::io::stdin().lock().read_line(&mut line) {
+            Ok(0) => None,
+            Ok(_) => {
+                while line.ends_with('\n') || line.ends_with('\r') {
+                    line.pop();
+                }
+                Some(line)
+            }
+            Err(_) => None,
+        }
+    }
+
+    fn sleep(&mut self, secs: f64) {
+        if secs > 0.0 {
+            std::thread::sleep(std::time::Duration::from_secs_f64(secs));
+        }
+    }
+}
+
+/// Capture-Host für Tests: zeichnet die Ausgabe byte-genau auf und
+/// liefert vorbereitete Eingabezeilen.
+#[derive(Default)]
+pub struct CaptureHost {
+    pub output: String,
+    pub input: VecDeque<String>,
+}
+
+impl CaptureHost {
+    pub fn with_input(lines: &[&str]) -> Self {
+        CaptureHost {
+            output: String::new(),
+            input: lines.iter().map(|s| s.to_string()).collect(),
+        }
+    }
+}
+
+impl Host for CaptureHost {
+    fn write(&mut self, s: &str) {
+        self.output.push_str(s);
+    }
+
+    fn read_line(&mut self) -> Option<String> {
+        self.input.pop_front()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn capture_host_zeichnet_bytegenau_auf() {
+        let mut h = CaptureHost::default();
+        h.write(" 1  2 ");
+        h.write("\n");
+        h.write("x");
+        assert_eq!(h.output, " 1  2 \nx");
+    }
+}