gui: TestCoveredWindowStaysUp hides magpie and checks the window in one step, so the activation its open asked for can't unhide magpie in between (macos-latest, CI run 37942751214)

Cause: on macos-latest the helper exited 1 with "window up: timed out
waiting until magpie is hidden" (6.06 s: the whole 5 s wait). It passed
on 3cd0b5f7's own run and the ten green runs after it, so it is a flake,
not a missing window server: the open and covered steps before it
passed on the same machine. Opening the window (openMain -> showHere ->
Focus) asks the Mac to activate magpie, which it does through the
window server and the run loop, not at once. On a loaded CI machine that
activation can still be pending when the test hides magpie a moment
later; it lands right after the hide and unhides magpie, which puts the
window back, so every poll found it open. NSApp hide: itself is
synchronous here (hidden with no window ordered in, in the same
main-thread block), active or not, and under full CPU load. That the
CI log has no line between is inferred from this: the only thing that
puts a hidden app's windows back is unhiding it, and the helper's only
activation is the open's.

Change: the test's hide step hides magpie and reads whether the window
counts as up in one block on the main thread, and hides again when it
finds magpie shown again. No production code changes: a user can't hide
magpie with Command-H before it is active. Not skipped: the test needs
nothing CI lacks.

Run:
- The old step with a late activation injected (queued from another
  goroutine while the hide block runs, not committed): FAIL 3 of 3,
  "window up: timed out waiting until magpie is hidden" in 5.8-6.3 s,
  the CI failure. The new step with the same injection: ok, 3 of 3.
- Guarantee still checked: windowUp with its "open as magpie was hidden"
  clause removed fails the new test, "hidden with magpie: the window
  counts as up=false, want true".
- go test -count=10 -run TestCoveredWindowStaysUp ./internal/gui: ok.
  Before the change, load alone didn't reproduce it here: three copies
  at a time, 15 runs, with a busy loop on every core, all passed.
- gofmt -l: nothing. go vet ./internal/gui (darwin), GOOS=linux and
  GOOS=windows go vet -tags nogui ./internal/gui, GOOS=windows go vet
  ./internal/gui: clean. go test ./internal/gui (darwin, under a temp
  HOME with pinned caches): ok.

internal/gui/window_up_darwin_test.go

@@ -85,10 +85,22 @@ func init() {
 			expect("covered", true)
 			application.InvokeSync(func() { cover.Close() })
 
-			// hidden with magpie, as by Command-H
-			application.InvokeSync(app.Hide)
-			waitFor("magpie is hidden", func() bool { return !windowOpen(h.main) })
-			expect("hidden with magpie", true)
+			// hidden with magpie, as by Command-H. Opening asked the Mac to
+			// activate magpie (Focus), and on a loaded CI machine that
+			// activation can land after the hide, which unhides magpie and
+			// shows the window again: the hide and the check are one step on
+			// the main thread, and a hide undone that way is done again.
+			var hiddenUp bool
+			waitFor("magpie is hidden", func() bool {
+				if windowOpen(h.main) {
+					app.Hide()
+				}
+				hiddenUp = kept()
+				return !windowOpen(h.main)
+			})
+			if !hiddenUp {
+				fail("hidden with magpie: the window counts as up=false, want true")
+			}
 			application.InvokeSync(app.Show)
 			waitFor("magpie is shown again", func() bool { return windowOpen(h.main) })