feat(wails): move the Go side to v3

Phases 2 and 3 of plan 009, plus the parts of phase 1 that could not
land before them. Nothing in the tree imports wails/v2 any more; all
three lint and test configurations are green and `go build .` produces
a running binary.

The point of the migration is one file. backend/events/emit.go probed
ctx.Value("events") — a v2-*private* context key — to decide whether
emitting was safe, because runtime.EventsEmit called log.Fatalf on a
context without the runtime and took the process down with it. v3's
emit takes no context, so that is now application.Get() == nil. D1
held: events.Emit keeps its ctx as the WithSink test seam, and all 45
call sites and 7 test files are untouched.

The bootstrap splits into application.New + Window.NewWithOptions +
Run. Ten bound services implement ServiceStartup instead of being
handed a context by hand from OnStartup, which also stops ten
SetContext methods being exported as bindings. jobs.Registry and
explore.SearchIndex keep theirs — neither is bound, so converting them
would be churn for no binding removed.

Four things differed from the plan and are written up in it: GPU policy
moved to the per-window LinuxWindow options rather than surviving on
LinuxOptions; there is no OnStartup/OnDomReady option, so app-level
wiring hangs off ApplicationStarted; application.NewService is generic,
so FEBindings []any could not survive (the binding generator is a
static analyser and would have seen nothing); and the quit veto had to
be restructured, because v3's dialog answers on a callback rather than
returning the button, so ShouldQuit vetoes, asks, and quits again from
the callback.

Window state saving moves to a WindowClosing hook — the size has to be
read while the window still exists, and v3's OnShutdown has neither
context nor window. backend/logging is deleted rather than ported:
v3 takes a *slog.Logger directly, so the v2 logger.Logger adapter had
no caller left.

Phase 1's tail rides along, now that it can: the Makefile's wails
invocations, all 50 webkit2_41 sites, lefthook, both packaging recipes
and ci.yml's apt lists. v3 builds against GTK4 + WebKitGTK 6.0, which
Arch and ubuntu:24.04 both ship, so the tag is a deletion rather than
a translation.

Phase 4 is next and the branch is not usable until it lands: the app
builds, but frontend/wailsjs/ is v2's tree and nothing regenerates it,
so the frontend cannot reach the backend yet.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UDCbcCZQepnpSQYJ6SxxZm

main.go

@@ -8,14 +8,12 @@ import (
 	"strings"
 
 	"github.com/golang-cz/devslog"
-	"github.com/wailsapp/wails/v2"
-	"github.com/wailsapp/wails/v2/pkg/options"
-	"github.com/wailsapp/wails/v2/pkg/options/linux"
+	"github.com/wailsapp/wails/v3/pkg/application"
+	"github.com/wailsapp/wails/v3/pkg/events"
 
 	"yellowjacket/backend"
 	"yellowjacket/backend/assets"
 	"yellowjacket/backend/config"
-	"yellowjacket/backend/logging"
 	"yellowjacket/backend/profiling"
 	"yellowjacket/internal/dev"
 )
@@ -69,33 +67,52 @@ func main() {
 		os.Exit(1)
 	}
 
-	// Create application with options
 	winCfg := yjApp.WindowConfig()
 
-	err = wails.Run(&options.App{
-		Title:  "yellowjacket",
-		Width:  winCfg.Width,
-		Height: winCfg.Height,
-		Logger: logging.NewLogger(
-			sLogger,
-			[]string{},
-		),
-		AssetServer:      assetHandler.Options,
-		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
-		OnStartup:        yjApp.OnStartup,
-		OnDomReady:       yjApp.OnDomReady,
-		OnBeforeClose:    yjApp.OnBeforeClose,
-		OnShutdown:       yjApp.OnShutdown,
-		Bind:             yjApp.FEBindings,
+	app := application.New(application.Options{
+		Name:        "yellowjacket",
+		Description: "A cross-platform desktop music player",
+		Services:    yjApp.Services,
+		Assets:      assetHandler.Options,
+		// v3 logs through slog directly, so v2's logger.Logger adapter
+		// (backend/logging) is gone rather than ported.
+		Logger:     sLogger,
+		ShouldQuit: yjApp.ShouldQuit,
+		OnShutdown: yjApp.OnShutdown,
+	})
+
+	// The services' own ServiceStartup hooks have run by the time this
+	// fires; what is left is the wiring between them.
+	app.Event.OnApplicationEvent(
+		events.Common.ApplicationStarted,
+		func(*application.ApplicationEvent) {
+			yjApp.OnStartup(app.Context())
+			yjApp.OnDomReady(app.Context())
+		},
+	)
+
+	window := app.Window.NewWithOptions(application.WebviewWindowOptions{
+		Title:            "yellowjacket",
+		Width:            winCfg.Width,
+		Height:           winCfg.Height,
 		MinWidth:         config.MinWidth,
 		MinHeight:        config.MinHeight,
-		MaxWidth:         0,
-		MaxHeight:        0,
-		Linux: &linux.Options{
-			WebviewGpuPolicy: linux.WebviewGpuPolicyAlways,
+		BackgroundColour: application.NewRGB(27, 38, 54),
+		URL:              "/",
+		Linux: application.LinuxWindow{
+			WebviewGpuPolicy: application.WebviewGpuPolicyAlways,
 		},
 	})
 
+	// The window's size has to be read while the window still exists,
+	// which OnShutdown is too late for.
+	window.OnWindowEvent(
+		events.Common.WindowClosing,
+		func(*application.WindowEvent) { yjApp.SaveWindowState(window) },
+	)
+
+	err = app.Run()
+
 	stopProfiler()
 
 	if err != nil {