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/console.rs

@@ -0,0 +1,112 @@
+//! Konsolen-Druckzustand: Spaltenverfolgung, PRINT-Formatierung,
+//! 14-Zeichen-Druckzonen, TAB/SPC. Wirkung ausschließlich über `Host`.
+
+use crate::format::format_print;
+use crate::host::Host;
+use crate::value::Value;
+
+/// Breite einer Druckzone (Vorbild: 14 Zeichen).
+pub const ZONE_WIDTH: usize = 14;
+
+/// Druckzustand (Spalte 0-basiert, in Zeichen).
+#[derive(Default)]
+pub struct PrintState {
+    pub col: usize,
+}
+
+impl PrintState {
+    /// Text ausgeben und Spalte nachführen.
+    pub fn write(&mut self, host: &mut dyn Host, s: &str) {
+        host.write(s);
+        match s.rfind('\n') {
+            Some(i) => self.col = s[i + 1..].chars().count(),
+            None => self.col += s.chars().count(),
+        }
+    }
+
+    /// Ein PRINT-Element: Zahlen mit Vorzeichenspalte und nachgestelltem
+    /// Leerzeichen, Strings unverändert.
+    pub fn print_value(&mut self, host: &mut dyn Host, v: &Value) {
+        match v {
+            Value::Str(s) => {
+                let s = s.clone();
+                self.write(host, &s);
+            }
+            _ => {
+                let s = format_print(v);
+                self.write(host, &s);
+            }
+        }
+    }
+
+    /// `,` — Sprung zur nächsten Druckzone (belegte Zone → übernächste).
+    pub fn print_comma(&mut self, host: &mut dyn Host) {
+        let next = (self.col / ZONE_WIDTH + 1) * ZONE_WIDTH;
+        let pad = next - self.col;
+        self.write(host, &" ".repeat(pad));
+    }
+
+    /// `TAB(n)` — zur Spalte n (1-basiert); liegt der Cursor bereits
+    /// dahinter, zuerst Zeilenumbruch (Vorbild).
+    pub fn print_tab(&mut self, host: &mut dyn Host, n: i32) {
+        let target = (n.max(1) as usize) - 1;
+        if self.col > target {
+            self.write(host, "\n");
+        }
+        if target > self.col {
+            let pad = target - self.col;
+            self.write(host, &" ".repeat(pad));
+        }
+    }
+
+    /// `SPC(n)` — n Leerzeichen.
+    pub fn print_spc(&mut self, host: &mut dyn Host, n: i32) {
+        if n > 0 {
+            self.write(host, &" ".repeat(n as usize));
+        }
+    }
+
+    pub fn print_newline(&mut self, host: &mut dyn Host) {
+        self.write(host, "\n");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::host::CaptureHost;
+
+    #[test]
+    fn druckzonen() {
+        let mut ps = PrintState::default();
+        let mut h = CaptureHost::default();
+        // "a" (1 Zeichen) , → Spalte 14
+        ps.write(&mut h, "a");
+        ps.print_comma(&mut h);
+        ps.write(&mut h, "b");
+        assert_eq!(h.output, "a             b");
+        assert_eq!(ps.col, 15);
+    }
+
+    #[test]
+    fn volle_zone_springt_zur_uebernaechsten() {
+        let mut ps = PrintState::default();
+        let mut h = CaptureHost::default();
+        ps.write(&mut h, "12345678901234"); // 14 Zeichen, Zone voll
+        ps.print_comma(&mut h);
+        ps.write(&mut h, "x");
+        // x beginnt in Spalte 29 (1-basiert) = Index 28
+        assert_eq!(h.output.chars().count(), 29);
+        assert!(h.output.ends_with("x"));
+    }
+
+    #[test]
+    fn zahlen_mit_vorzeichenspalte() {
+        let mut ps = PrintState::default();
+        let mut h = CaptureHost::default();
+        ps.print_value(&mut h, &Value::Int(1));
+        ps.print_value(&mut h, &Value::Int(-2));
+        ps.print_newline(&mut h);
+        assert_eq!(h.output, " 1 -2 \n");
+    }
+}