feat(overlay): the toolbar gets its own window, so it can never move or vanish

The pill was drawn inside the catcher's ZStack, which made its position a
function of the catcher panel's frame. That frame changes size on every
open/close, is narrowed to the visible screen, and is dragged around by
AppKit whenever the host moves -- three ways for a control that must never
move to move -- and anything that stalled the catcher (a wedged scroll, a
rebuilt SwiftUI root) took the pill down with it.

The toolbar now has its own permanently mounted panel: fixed size, pinned
to the host's bottom-right, re-placed only when the host moves, resizes or
changes screen. Opening the menu creates a SEPARATE catcher panel over the
host and closing it tears that panel down. The menu is now genuinely just
open or closed, and the toolbar itself is untouched by the transition.

Ordering matters and is not free: re-adding an existing child window does
NOT re-stack it (measured -- childWindows still ended with the catcher, and
the catcher sat on top, eating the click that closes the menu). The toolbar
is detached and re-added, then ordered explicitly above the catcher.

Probe updated for the two-panel world: childWindows.first is no longer "the
overlay", and BOTH panels carry the AX identifier -- correctly, since the
point query must skip both -- so 7g now picks the panel that actually spans
the host rather than the first match.

191 tests, probe 11/11, iOS cross-compile clean.

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

Author: angusbezzina

Sources/AnnotKit/Overlay/OverlayView.swift

@@ -86,7 +86,6 @@ struct OverlayView: View {
                 editCard(note: note, anchor: anchor)
             }
 
-            toolbar
         }
         .ignoresSafeArea()
         .accessibilityHidden(true)
@@ -577,9 +576,29 @@ struct OverlayView: View {
         )
     }
 
-    /// Pins the compact pill to the host window's bottom-right corner (margin 20,
-    /// matching the idle child-window frame the controller sizes).
-    private var toolbar: some View {
+}
+
+/// The toolbar pill, in a window of its OWN.
+///
+/// The pill used to be drawn inside the catcher's ZStack, which meant its position
+/// was a function of the catcher panel's frame — and that frame changes size on
+/// every open/close, gets narrowed to the visible screen, and is dragged around by
+/// AppKit whenever the host window moves. Three ways for a control that must never
+/// move to move, and a fourth failure on top: anything that stalled the catcher
+/// (a wedged scroll, a rebuilt SwiftUI root) took the pill down with it.
+///
+/// Giving it a separate, permanently mounted panel makes the guarantee structural
+/// rather than incidental: the pill is always present, always at the host's
+/// bottom-right corner, and the catcher's geometry and lifetime cannot touch it.
+/// The menu is now genuinely just OPEN or CLOSED — the toolbar itself never moves
+/// between the two.
+struct ToolbarOverlayView: View {
+    @ObservedObject var session: AnnotationSession
+    let onToggle: () -> Void
+    let onCopy: () -> Void
+    let onExport: () -> Void
+
+    var body: some View {
         VStack {
             Spacer()
             HStack {
@@ -593,6 +612,8 @@ struct OverlayView: View {
                 .padding(20)
             }
         }
+        .ignoresSafeArea()
+        .accessibilityHidden(true)
     }
 }
 
@@ -741,7 +762,7 @@ private struct AnnotationCard<Footer: View>: View {
 /// The pill itself is rendered unconditionally and is NEVER gated on an entrance
 /// flag, so it stays visible across idle<->annotate; only its contents swap as
 /// annotate mode toggles.
-private struct ToolbarView: View {
+struct ToolbarView: View {
     @ObservedObject var session: AnnotationSession
     let onToggle: () -> Void
     let onCopy: () -> Void