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-frontend/src/parser.rs

@@ -285,15 +285,15 @@ impl<'a> P<'a> {
                     return None;
                 }
                 self.advance();
-                Some(Stmt::End)
+                Some(Stmt::End(pos))
             }
             TokenKind::Kw(Kw::Stop) => {
                 self.advance();
-                Some(Stmt::StopStmt)
+                Some(Stmt::StopStmt(pos))
             }
             TokenKind::Kw(Kw::System) => {
                 self.advance();
-                Some(Stmt::System)
+                Some(Stmt::System(pos))
             }
             TokenKind::Kw(Kw::Exit) => {
                 self.advance();
@@ -1498,7 +1498,16 @@ impl<'a> P<'a> {
         }
         // Impliziter Aufruf: `name [arg [, arg …]]`
         if let Expr::Name { name, suffix, args, .. } = target {
-            let mut call_args = args.unwrap_or_default();
+            // Ohne CALL-Keyword sind Klammern Wert-Klammern (BYVAL), keine
+            // Argumentlisten-Klammern: `Foo (n%)` übergibt `(n%)`.
+            let mut call_args: Vec<Expr> = args
+                .unwrap_or_default()
+                .into_iter()
+                .map(|a| match a {
+                    p @ Expr::Paren(_) => p,
+                    other => Expr::Paren(Box::new(other)),
+                })
+                .collect();
             if !self.at_stmt_end() && call_args.is_empty() {
                 call_args = self.parse_arg_list_to_stmt_end();
             }
@@ -1722,7 +1731,7 @@ impl<'a> P<'a> {
                 if !self.eat(&TokenKind::RParen) {
                     self.err("Expected: )");
                 }
-                Some(e)
+                Some(Expr::Paren(Box::new(e)))
             }
             TokenKind::Ident { .. } => self.parse_name_ref(),
             _ => {