fix(linux): the update relaunch is per-platform again

Restoring the PowerShell helper put it in update.go, which is shared —
so a Linux build would have tried to run `powershell` to relaunch
itself. It compiled and vetted cleanly for linux/amd64, which is exactly
why it needed catching before somebody built it: the fault only shows on
a real update, on a machine that has no PowerShell.

scheduleRelaunch now lives in the platform files. Windows keeps the
helper. Linux starts the new binary directly, which is right there and
not a compromise: nothing holds an executable open while it runs, so the
swap has already succeeded, and there is no mutex to race — the
single-instance guard is an flock the dying process releases as it
exits, and the new one waits for our pid first.

The two guards were looking at the old location and had to follow: the
Wait-Process/Start-Process check moves into relaunch_windows_test.go
where it belongs, and TestEveryRelaunchPassesItsPid now scans
updateswap_linux.go too — the direct spawn moved there, and without it
the test would have gone quiet again.

Checked from Windows, as BUILDING-LINUX.md says is done at every
release: GOOS=linux go build ./... and go vet ./... both clean.

relaunch_windows_test.go

@@ -3,7 +3,9 @@
 package main
 
 import (
+	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 )
 
@@ -48,3 +50,28 @@ func TestRelaunchIsDetached(t *testing.T) {
 		t.Error("CREATE_NEW_PROCESS_GROUP is missing: a cleanup aimed at the old instance can reach the new one")
 	}
 }
+
+// The update relaunch goes through a helper that OUTLIVES this process.
+//
+// Two rewrites started the new exe from inside the dying one instead, and both
+// left operators with no window after an update: the launch then happens while
+// this process is still alive and still holds the mutex. The helper waits for
+// our pid first. Restored from before 0430aab and pinned here so a third
+// rewrite has to argue with the two reports rather than rediscover them.
+func TestWindowsUpdateRelaunchWaitsForUsFromOutside(t *testing.T) {
+	src, err := os.ReadFile("updateswap_windows.go")
+	if err != nil {
+		t.Fatalf("read updateswap_windows.go: %v", err)
+	}
+	got := string(src)
+	for _, want := range []string{"Wait-Process -Id", "Start-Process -FilePath"} {
+		if !strings.Contains(got, want) {
+			t.Errorf("the relaunch no longer contains %q — it must wait for this process from outside it", want)
+		}
+	}
+	// Start-Process shows the new window normally. A direct exec.Command(exe…)
+	// is the shape that broke it, twice.
+	if strings.Contains(got, "exec.Command(exe") {
+		t.Error("the Windows relaunch starts the new exe directly again")
+	}
+}