Start the panel slide after the window is on screen (#24)

The reveal animation ran on the content inside a fixed panel frame, but it
was started in the same turn as `orderFrontRegardless()`. Ordering a window
in is not instant: the window server needs a composited frame first.
Measured on a real launch, that gap is 47-62ms (six samples, mean 53ms).

The slide is a 250ms easeOut, so those ~50ms are 20% of the duration and,
on that curve, about 36% of the distance. The panel therefore materialised
already a third of the way up and read as a pop rather than a slide.
`hidePanel` was unaffected because its window is already on screen when it
animates, which is why closing looked right and opening did not.

Push the parked first frame out with `displayIfNeeded()` + a CATransaction
flush, then start the slide on the next main actor turn so the whole curve
happens on screen. Also drop the window shadow before ordering in, so the
first composited frame never carries a shadow around empty space.

Costs ~50ms before the content starts moving. Total hotkey-to-open is about
310ms, still well below the 168ms build cost this path had before #18.

Co-authored-by: mobrava <82764703+mobrava@users.noreply.github.com>

Author: evowhale

Clipbara/Panel/PanelController.swift

@@ -111,29 +111,42 @@ final class PanelController {
         // end up on the wrong screen.
         contentHost?.frame.origin.y = -endFrame.height
         panel?.alphaValue = 1
-        panel?.orderFrontRegardless()
-        panel?.makeKey()
-        panel?.makeFirstResponder(nil)
 
         // The window shadow is derived from the content alpha. While the
         // content is only partly inside the frame the shadow would outline
         // empty space, so drop it for the duration of the slide.
         panel?.hasShadow = false
 
-        NSAnimationContext.runAnimationGroup({ [contentHost] context in
-            context.duration = 0.25
-            context.timingFunction = CAMediaTimingFunction(name: .easeOut)
-            if let contentHost {
+        panel?.orderFrontRegardless()
+        panel?.makeKey()
+        panel?.makeFirstResponder(nil)
+
+        // Ordering a window in is not instant: the window server needs a
+        // composited frame before anything reaches the screen. Starting the
+        // slide in this same turn meant the easeOut curve was already most of
+        // the way through by the time the panel actually appeared, so the
+        // content popped in instead of riding up. Push the parked first frame
+        // out now, then start the slide on the next main actor turn so the
+        // whole curve happens on screen. `hidePanel` never had this problem
+        // because its window is already visible when it animates.
+        panel?.contentView?.displayIfNeeded()
+        CATransaction.flush()
+
+        Task { @MainActor [weak self] in
+            guard let self, let contentHost = self.contentHost else { return }
+            NSAnimationContext.runAnimationGroup({ context in
+                context.duration = 0.25
+                context.timingFunction = CAMediaTimingFunction(name: .easeOut)
                 var target = contentHost.frame
                 target.origin.y = 0
                 contentHost.animator().frame = target
-            }
-        }, completionHandler: { [weak self] in
-            Task { @MainActor in
-                self?.panel?.hasShadow = true
-                self?.panel?.invalidateShadow()
-            }
-        })
+            }, completionHandler: {
+                Task { @MainActor [weak self] in
+                    self?.panel?.hasShadow = true
+                    self?.panel?.invalidateShadow()
+                }
+            })
+        }
 
         isVisible = true
         appState.markPanelPresented()