[REFACTOR] VF-Linienzug: vfl-in-* Wrapper auf gemeinsames Skelett reduziert

vfl-in-point/-string/-real/-int teilten exakt dasselbe 3-Zweig-Muster
(Replay-Queue -> Pending-Queue -> Live-Eingabe -> Journal). Skelett jetzt
EINMAL in vfl-in-value; die vier Wrapper liefern nur noch livefn + kind.

- vfl-in-value: unveraendertes Default-Skelett (v non-nil = gueltig)
- vfl-in-value-p: Variante mit explizitem Gueltig-Praedikat, fuer vfl-in-string
  ("" ist ein gueltiger String -> striktes STR-Praedikat, Verhalten identisch)
- vfl-in-selection bleibt eigenstaendig (OBJS/Handle-Sonderlogik)

Signaturen + Journal-Format unveraendert, alle 63 Aufrufstellen bleiben gueltig.
Dynamic scoping: livefn-Lambdas sehen prompt/base/*vfl-wizard-mode* etc. ueber
den aktiven Wrapper-Frame. ~40 Zeilen weniger. Paren-Balance geprueft.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Lisp/vf_linienzug.lsp

@@ -844,15 +844,16 @@
 ;; --- Eingabe-Wrapper ---
 ;; kind steuert nur, wie ein FRISCH live erfasster Wert typisiert wird; beim
 ;; Replay wird der gespeicherte Wert unveraendert durchgereicht.
-(defun vfl-in-point (base prompt / popped v)
-  (setq popped (if *vfl-replay-queue* (vfl-replay-pop) nil))
-  (if popped
-    (setq v (car popped))
-    (progn
-      (setq popped (vflw-pending-pop))
-      (if popped (setq v (car popped)) (setq v (vfl-getpoint base prompt)))))
-  (vfl-journal-record (if v "PT" "NIL") v)
-  v)
+;;
+;; Alle Basis-Wrapper teilen dasselbe 3-Zweig-Muster (Replay-Queue ->
+;; Pending-Queue -> Live-Eingabe) plus Journal-Aufzeichnung. Dieses Skelett
+;; ist EINMAL in vfl-in-value (weiter unten) implementiert; die folgenden
+;; Wrapper liefern nur ihre Live-Eingabe-Funktion (livefn) und ihr kind-Tag.
+;; Journal-Format und Signaturen bleiben damit unveraendert (63 Aufrufstellen).
+;; Ausnahme: vfl-in-selection (OBJS/Handles) hat abweichende Replay-/Journal-
+;; Logik und bleibt eigenstaendig.
+(defun vfl-in-point (base prompt)
+  (vfl-in-value "PT" (function (lambda () (vfl-getpoint base prompt)))))
 
 ;; Objektauswahl (Modus 2: Pfad-Objekte). Wie die anderen Wrapper repliziert
 ;; bzw. journalisiert - aber KEIN Wizard-Dialog (Objektwahl braucht wie
@@ -890,52 +891,31 @@
   (vfl-journal-record (if v "OBJS" "NIL") handles)
   v)
 
-(defun vfl-in-string (prompt / popped v)
-  (setq popped (if *vfl-replay-queue* (vfl-replay-pop) nil))
-  (if popped
-    (setq v (car popped))
-    (progn
-      (setq popped (vflw-pending-pop))
-      (if popped
-        (setq v (car popped))
-        (setq v
-          (if (and *vfl-wizard-mode* *vflw-menu-optionen*)
-            (vflw-wahl (if *vflw-menu-frage* (ssg-text *vflw-menu-frage*) prompt)
-                       *vflw-menu-optionen* *vflw-menu-default*)
-            (getstring prompt))))))
-  ;; "" (Enter/Abbruch) ist ein gueltiger String, kein Abbruch -> "STR".
-  (vfl-journal-record (if (eq (type v) 'STR) "STR" "NIL") v)
-  v)
+;; String: "" (Enter) ist ein GUELTIGER String (kein Abbruch) -> "STR". Daher
+;; das strikte STR-Praedikat statt der Default-non-nil-Pruefung.
+(defun vfl-in-string (prompt)
+  (vfl-in-value-p "STR"
+    (function (lambda (v) (eq (type v) 'STR)))
+    (function (lambda ()
+      (if (and *vfl-wizard-mode* *vflw-menu-optionen*)
+        (vflw-wahl (if *vflw-menu-frage* (ssg-text *vflw-menu-frage*) prompt)
+                   *vflw-menu-optionen* *vflw-menu-default*)
+        (getstring prompt))))))
 
-(defun vfl-in-real (prompt / popped v)
-  (setq popped (if *vfl-replay-queue* (vfl-replay-pop) nil))
-  (if popped
-    (setq v (car popped))
-    (progn
-      (setq popped (vflw-pending-pop))
-      (if popped
-        (setq v (car popped))
-        (setq v (if *vfl-wizard-mode* (vflw-zahl prompt) (getreal prompt))))))
-  (vfl-journal-record (if v "REAL" "NIL") v)
-  v)
+(defun vfl-in-real (prompt)
+  (vfl-in-value "REAL"
+    (function (lambda ()
+      (if *vfl-wizard-mode* (vflw-zahl prompt) (getreal prompt))))))
 
-(defun vfl-in-int (prompt / popped v vs)
-  (setq popped (if *vfl-replay-queue* (vfl-replay-pop) nil))
-  (if popped
-    (setq v (car popped))
-    (progn
-      (setq popped (vflw-pending-pop))
-      (if popped
-        (setq v (car popped))
-        (setq v
-          (if (and *vfl-wizard-mode* *vflw-menu-optionen*)
-            (progn
-              (setq vs (vflw-wahl (if *vflw-menu-frage* (ssg-text *vflw-menu-frage*) prompt)
-                                  *vflw-menu-optionen* *vflw-menu-default*))
-              (if (and vs (> (strlen vs) 0)) (atoi vs) nil))
-            (getint prompt))))))
-  (vfl-journal-record (if v "INT" "NIL") v)
-  v)
+(defun vfl-in-int (prompt)
+  (vfl-in-value "INT"
+    (function (lambda ( / vs)
+      (if (and *vfl-wizard-mode* *vflw-menu-optionen*)
+        (progn
+          (setq vs (vflw-wahl (if *vflw-menu-frage* (ssg-text *vflw-menu-frage*) prompt)
+                              *vflw-menu-optionen* *vflw-menu-default*))
+          (if (and vs (> (strlen vs) 0)) (atoi vs) nil))
+        (getint prompt))))))
 
 ;; Menue-Wrapper: princ-Ausgabe der Optionen bleibt beim Aufrufer unveraendert
 ;; stehen (Konsolen-Fallback, de/en via ssg-text) - hier wird nur die
@@ -1004,11 +984,16 @@
                 (T v)))
   (if (member n winkel-werte) n default-winkel))
 
-;; Generischer Wrapper fuer eine Eingabe, die nicht direkt ein getXXX ist,
-;; sondern das Ergebnis einer fragenden Hilfsfunktion (z.B. die gemeinsame
-;; vf-frage-element-winkel). livefn ist ein aufrufbares Objekt ohne Argumente;
-;; sein Rueckgabewert wird mit dem angegebenen kind journalisiert bzw. beim
-;; Replay aus der Queue geliefert (livefn wird dann NICHT aufgerufen).
+;; Generisches Eingabe-Skelett: der gemeinsame 3-Zweig-Ablauf (Replay-Queue ->
+;; Pending-Queue -> Live-Eingabe) plus Journal-Aufzeichnung, den alle Basis-
+;; Wrapper (vfl-in-point/-string/-real/-int) teilen. livefn ist ein aufrufbares
+;; Objekt ohne Argumente (die eigentliche Live-Eingabe, z.B. getpoint/getreal
+;; oder eine fragende Hilfsfunktion wie vf-frage-element-winkel); es wird NUR
+;; aufgerufen, wenn weder Replay- noch Pending-Wert vorliegt.
+;; kind: Journal-Typ eines frisch/gueltig erfassten Werts. Ein non-nil v gilt
+;; als gueltig (-> kind), nil als Abbruch (-> "NIL"). Fuer Faelle, in denen die
+;; Gueltigkeit strenger geprueft werden muss (z.B. vfl-in-string: "" ist ein
+;; gueltiger String), siehe vfl-in-value-p.
 (defun vfl-in-value (kind livefn / popped v)
   (setq popped (if *vfl-replay-queue* (vfl-replay-pop) nil))
   (if popped
@@ -1019,6 +1004,17 @@
   (vfl-journal-record (if v kind "NIL") v)
   v)
 
+;; Variante mit explizitem Gueltig-Praedikat (fuer vfl-in-string: "" ist gueltig).
+(defun vfl-in-value-p (kind gueltig-p livefn / popped v)
+  (setq popped (if *vfl-replay-queue* (vfl-replay-pop) nil))
+  (if popped
+    (setq v (car popped))
+    (progn
+      (setq popped (vflw-pending-pop))
+      (if popped (setq v (car popped)) (setq v (apply livefn nil)))))
+  (vfl-journal-record (if (apply gueltig-p (list v)) kind "NIL") v)
+  v)
+
 ;; --- String-Hilfen (generisch, Trenner beliebig) ---
 (defun vfl-strjoin (lst sep / s first)
   (setq s "" first t)