Zeichnungsmanager Master-Controls + Scheren + Startup-Perf + Oeffnung-Preview

UI:
- GeschossManager: Master-Eye + Master-Lock im Header (analog EbenenManager).
  Scheren-Button pro Geschoss togglet hasClipping. Auge ganz links wie bei
  Ebenen. Eye-Logik klar 4-Wege: aktive Z immer hell+on, in 'active'/'all_force'
  fuer non-active gedimmt, sonst spiegelt Flag direkt. Schrift wird NIE gegrayt.
  Neuer Mode 'all_force' = "Alle anzeigen" (ignoriert Eye), 'all' jetzt mit
  Label "Ausgewaehlte" (respektiert Eye). Klick aufs Auge in 'active'/'all_force'
  wechselt automatisch in "Ausgewaehlte" damit Aktion sofort wirkt.

- layer_builder.apply_visibility: neuer z_mode 'all_force' vor visible-Check —
  zeigt jede Z auch wenn Eye=false war.

- elemente._cmd_create_oeffnung: gruene Live-Preview (vertikales Oeffnungs-
  Rechteck + Breiten-Marker + Diagonale) waehrend Fenster/Tuer-Platzierung
  entlang der Wand-Achse. Brueest-Offset aus Geschoss-UK korrekt im Z.

Performance Cold-Start:
- panel_base: Inlined-HTML als Modul-Cache (1x build, n-mal mount). Pro
  Panel-Mount nur noch str.replace + LoadHtml. Spart bei 10 Panels 9x
  ~395 KB Disk-Read + Regex-Pass. Cache-Key = mtime von dist/index.html.

- Timing-Instrumentierung: _t_mark + print_startup_summary. Hook in startup.py
  feuert 3s nach Plugin-Load + listet Wall-time, Top-10, Aggregat pro Phase.

- OberleisteBridge: Command-Enumeration (~1000 Commands) jetzt lazy via
  Rhino.RhinoApp.Idle statt synchron im __init__. Cold-Start nicht blockiert,
  Autocomplete kommt ~1 Frame spaeter.

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

rhino/elemente.py

@@ -503,6 +503,46 @@ def _make_circle_preview(center):
     return handler
 
 
+def _make_oeffnung_preview(axis_curve, breite, hoehe, brueest, base_z):
+    """Preview fuer Fenster/Tuer-Platzierung. Zeigt das vertikale Rechteck
+    der Oeffnungsflaeche auf Hoehe der Achse (entlang Tangente x Hoehe),
+    zusaetzlich eine Marker-Linie auf der Achse die die Breite andeutet."""
+    import System.Drawing as SD
+    color      = SD.Color.FromArgb(255, 95, 200, 180)  # Accent gruen
+    color_axis = SD.Color.FromArgb(180, 95, 200, 180)  # halbtransparent
+    def handler(sender, e):
+        try:
+            cur = e.CurrentPoint
+            ok, t = axis_curve.ClosestPoint(cur)
+            if not ok: return
+            on_axis = axis_curve.PointAt(t)
+            tan = axis_curve.TangentAt(t)
+            tlen = (tan.X * tan.X + tan.Y * tan.Y) ** 0.5
+            if tlen < 1e-9: return
+            tx = tan.X / tlen; ty = tan.Y / tlen
+            hb = breite * 0.5
+            z_bot = base_z + brueest
+            z_top = z_bot + hoehe
+            cx, cy = on_axis.X, on_axis.Y
+            # Breiten-Marker auf der Achse
+            left_xy  = rg.Point3d(cx - hb * tx, cy - hb * ty, on_axis.Z)
+            right_xy = rg.Point3d(cx + hb * tx, cy + hb * ty, on_axis.Z)
+            e.Display.DrawLine(left_xy, right_xy, color_axis, 1)
+            # 4 Kanten der vertikalen Oeffnungs-Flaeche
+            p_lb = rg.Point3d(cx - hb * tx, cy - hb * ty, z_bot)
+            p_rb = rg.Point3d(cx + hb * tx, cy + hb * ty, z_bot)
+            p_rt = rg.Point3d(cx + hb * tx, cy + hb * ty, z_top)
+            p_lt = rg.Point3d(cx - hb * tx, cy - hb * ty, z_top)
+            for a, b in ((p_lb, p_rb), (p_rb, p_rt),
+                          (p_rt, p_lt), (p_lt, p_lb)):
+                e.Display.DrawLine(a, b, color, 2)
+            # Diagonalen — Andeutung der Glasflaeche
+            e.Display.DrawLine(p_lb, p_rt, color_axis, 1)
+            e.Display.DrawLine(p_lt, p_rb, color_axis, 1)
+        except Exception: pass
+    return handler
+
+
 def _collect_rectangle(doc, c1):
     """Achsen-aligned Rechteck aus 2 diagonalen Ecken. Liefert geschlossene
     PolylineCurve in XY-Ebene auf Z=0."""
@@ -5514,6 +5554,18 @@ class ElementeBridge(panel_base.BaseBridge):
         axis_curve = wall_obj.Geometry
         if not isinstance(axis_curve, rg.Curve): return
 
+        # Base-Z fuer das Preview: UK des Geschosses, damit das Brueest-
+        # Offset visuell stimmt (Achse selbst kann auf einem anderen Z
+        # liegen je nach Modellierung).
+        try:
+            wuk, _wok = _resolve_uk_ok(doc, wall_meta.get("geschoss"),
+                                        wall_meta.get("uk_override"),
+                                        wall_meta.get("ok_override"))
+            preview_base_z = float(wuk)
+        except Exception:
+            try: preview_base_z = float(axis_curve.PointAtStart.Z)
+            except Exception: preview_base_z = 0.0
+
         # 2) Punkt auf der Achse — constrained an die Wand-Achse
         try:
             while True:
@@ -5526,6 +5578,11 @@ class ElementeBridge(panel_base.BaseBridge):
                 gp.SetCommandPrompt(prompt)
                 try: gp.Constrain(axis_curve, False)
                 except Exception: pass
+                # Live-Preview: gruenes Oeffnungs-Rechteck auf der Wand
+                try:
+                    gp.DynamicDraw += _make_oeffnung_preview(
+                        axis_curve, breite, hoehe, brueest, preview_base_z)
+                except Exception: pass
                 opt_b  = gp.AddOption("Breite")
                 opt_h  = gp.AddOption("Hoehe")
                 opt_br = gp.AddOption("Bruestung") if typ == "fenster" else None