feat(linux): the Go half of OpsLog builds for Linux

Measured rather than guessed: the whole repository was cross-compiled for
linux/amd64 and the gaps closed one by one. There were fewer than expected.

Flex and TCI were never Windows-specific — they carried //go:build windows by
inheritance and import nothing but net and gorilla/websocket. Untagged, no code
change. The two backends a Linux operator is most likely to own were already
portable.

Audio was 560 lines, not 2287: only devices.go and engine.go touch WASAPI, while
manager.go, recorder.go, wav.go and mp3.go were pure Go wearing the tag by
association. The whole platform surface is seven functions, now implemented a
second time on PulseAudio through github.com/jfreymuth/pulse — pure Go over the
server socket, so the no-cgo rule survives, and PipeWire answers the same
protocol. The fixed 16 kHz mono format and the server-side resampling mirror
what AUTOCONVERTPCM does on Windows, for the same reason.

OmniRig is the only real loss, and its backend still EXISTS off Windows rather
than being compiled out of app.go: a settings database is portable, so an
operator moving a profile across keeps "omnirig" saved and must be told to pick
a native backend instead of meeting a nil one.

The parts where Linux is not Windows, and where a compile-only stub would have
been a silent bug:

  - data dir: still beside the binary, but ~/.local/share/OpsLog/data when that
    folder belongs to the system — decided by trying the write, because /opt and
    /usr/local are writable on some stations and not others.
  - single instance: an flock, not a pid file. The kernel drops it however the
    process dies, so a crash leaves nothing to delete by hand. This is the guard
    that stops two instances fighting over the rig frequency.
  - update: simpler here. Unix renames over a running binary, so the deferred
    swap the Windows path needs a detached helper for is unreachable.
  - tasklist/taskkill become /proc and SIGTERM; the boot log moves out of /tmp,
    which is wiped exactly when the evidence is wanted.
  - serial ports sorted naturally: /dev/ttyUSB10 was landing between USB1 and
    USB2, the same trap COM10 fell into.

release.ps1 now cross-builds and vets for linux before it builds the exe, and
refuses the release if that fails — a port rots one unguarded x/sys/windows call
at a time.

Nothing has been executed on Linux yet: Wails needs webkit2gtk and cgo there, so
the binary must be built on Linux. scripts/linux-setup.sh checks the machine and
does it; BUILDING-LINUX.md is the manual version.

Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>

update.go

@@ -11,7 +11,6 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
-	"syscall"
 	"time"
 
 	wruntime "github.com/wailsapp/wails/v2/pkg/runtime"
@@ -209,8 +208,11 @@ func (a *App) DownloadAndApplyUpdate(url string) error {
 	// Otherwise Windows SmartScreen wants to prompt "are you sure you want to open
 	// this?" — but since we launch the exe programmatically that prompt never shows,
 	// and the launch is silently blocked. This is exactly why the relaunch failed.
-	_ = os.Remove(exe + ":Zone.Identifier")
-	applog.Printf("update: installed new exe, scheduling relaunch")
+	clearDownloadMark(exe)
+	if err := makeExecutable(exe); err != nil {
+		applog.Printf("update: could not restore the executable bit on %s: %v", filepath.Base(exe), err)
+	}
+	applog.Printf("update: installed new build, scheduling relaunch")
 
 	// THE NEW EXE STARTS ITSELF. No helper, no script.
 	//
@@ -235,7 +237,7 @@ func (a *App) DownloadAndApplyUpdate(url string) error {
 	// helper never did: it waited for the pid, however long it took.
 	cmd := exec.Command(exe, "--post-update", "--wait-pid", strconv.Itoa(os.Getpid()))
 	cmd.Dir = dir
-	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true, CreationFlags: 0x08000000} // CREATE_NO_WINDOW
+	hideConsole(cmd)
 	if err := cmd.Start(); err != nil {
 		return fmt.Errorf("schedule relaunch: %w", err)
 	}
@@ -250,52 +252,6 @@ func (a *App) DownloadAndApplyUpdate(url string) error {
 	return nil
 }
 
-// scheduleDeferredSwap hands the exe swap to a detached helper that runs AFTER
-// this process is gone.
-//
-// The fallback for when the running image cannot be renamed at all. Once OpsLog
-// has exited its exe is an ordinary file again, so the move that was refused a
-// moment earlier succeeds — and the helper keeps trying for ten seconds, because
-// an antivirus that was holding the file usually lets go a beat after the
-// process dies rather than instantly.
-//
-// OpsLog is restarted either way. If the move failed, that starts the OLD build
-// — the update simply has not applied — and the operator keeps a working logger
-// instead of having it vanish mid-session, which for someone in a QSO is worse
-// than an update that waits. Only a successful swap passes --post-update, so a
-// failure leaves the .new file in place for the next attempt rather than having
-// the cleanup delete the download.
-// The LAST resort still needs a helper that outlives this process: nothing else
-// can move a file over an image that is still running. It stays PowerShell —
-// there is no smaller tool on a stock Windows that can wait for a pid and then
-// move a file — but it is reached only when the rename above failed, which is
-// rare, and never on the ordinary update path (see the relaunch there for why
-// that matters to Defender).
-func (a *App) scheduleDeferredSwap(exe, pending string) error {
-	// Clear the "downloaded from the internet" mark before it becomes the exe —
-	// SmartScreen silently blocks a programmatic launch of a marked file, and the
-	// mark follows the file across the move.
-	_ = os.Remove(pending + ":Zone.Identifier")
-
-	q := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
-	ps := fmt.Sprintf(
-		"Wait-Process -Id %d -ErrorAction SilentlyContinue; "+
-			"$ok=$false; "+
-			"for ($i=0; $i -lt 40; $i++) { "+
-			"try { Move-Item -LiteralPath '%s' -Destination '%s' -Force -ErrorAction Stop; $ok=$true; break } "+
-			"catch { Start-Sleep -Milliseconds 250 } }; "+
-			"if ($ok) { Start-Process -FilePath '%s' -ArgumentList '--post-update' } "+
-			"else { Start-Process -FilePath '%s' }",
-		os.Getpid(), q(pending), q(exe), q(exe), q(exe))
-	cmd := exec.Command("powershell", "-NoProfile", "-WindowStyle", "Hidden", "-Command", ps)
-	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true, CreationFlags: 0x08000000} // CREATE_NO_WINDOW
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("schedule the update swap: %w", err)
-	}
-	applog.Printf("update: swap scheduled for after exit (%s → %s)", filepath.Base(pending), filepath.Base(exe))
-	return nil
-}
-
 // downloadWithProgress streams url into dest, emitting "update:progress" (0-100).
 func (a *App) downloadWithProgress(url, dest string) error {
 	client := &http.Client{Timeout: 10 * time.Minute}