Adopt house golangci-lint config; fix all approved-linter findings

.golangci.yml is the prompts-repo standard verbatim plus one approved
exception (paralleltest, sneak 2026-07-06). Roughly 1,500 findings
fixed:

- autofix sweep (wsl_v5/nlreturn/intrange/modernize formatting), with
  the misspell autofix REVERTED where it rewrote authentic C game text
  ("missle vanishes" stays, with nolint and a comment)
- error handling: errcheck sites get real handling — saveFile now
  closes explicitly and removes corrupt saves, scoreboard writes are
  documented best-effort, err113 sentinel errors (ErrSaveOutOfDate,
  ErrScreenTooSmall); panics allowed for unrecoverable states per
  MEMORY.md policy
- gosec: real fixes (ParseInt for SEED, 0600 scorefile) and justified
  per-line nolints for provably-bounded conversions (randomMonsterLetter
  helper collapses eight rnd(26)+'A' sites)
- API tidying from linters: pointer receivers on flag types
  (recvcheck), msg helpers renamed addmsgf/doaddf/Printwf/MvPrintwf
  (goprintffuncname), myExit()/findFloor(monst)/mkGameInput(t) drop
  always-constant params (unparam), gameEnd carries no status
- gocritic/staticcheck: if-else chains to switches, the pack.c
  inventory filter untangled into matchesFilter, main.go split so
  defers run before exit (exitAfterDefer, funlen)
- revive doc comments on all exported flag types/consts/methods

Remaining findings are confined to linters pending sneak's exception
decision (mnd, gochecknoglobals, cyclop, nestif, gocognit, exhaustive,
goconst, testpackage); TODO.md records the state. MEMORY.md added at
repo root as the project's agent working notes.

game/run_test.go

@@ -9,21 +9,27 @@ import (
 // moves, a rest, an inventory, then Q-quit answered yes.
 func TestRunScriptedSession(t *testing.T) {
 	tt := &testTerm{input: []byte("hjkl.i Qy")}
+
 	g := NewGame(Config{Seed: 99, Term: tt})
-	if err := g.Run(); err != nil {
+
+	err := g.Run()
+	if err != nil {
 		t.Fatalf("Run: %v", err)
 	}
+
 	if g.Playing {
 		t.Error("still playing after quit")
 	}
 	// After quitting, the scoreboard is the last thing shown (in C it went
 	// to stdout after endwin; here it is drawn on the screen).
 	found := false
-	for y := 0; y < NumLines; y++ {
+
+	for y := range NumLines {
 		if strings.Contains(g.scr.Std.Line(y), "Top Ten") {
 			found = true
 		}
 	}
+
 	if !found {
 		t.Error("score list not on screen after quit")
 	}
@@ -36,17 +42,23 @@ func TestRunManyTurns(t *testing.T) {
 	// Spaces between commands double as answers to any --More-- prompts;
 	// without them a single prompt would swallow the rest of the script
 	// (wait_for eats everything that isn't a space).
-	var script []byte
-	moves := []byte("h h j j k k l l y u b n s s . . ")
+	moves := []byte("h j k l y u b n s .")
+	script := make([]byte, 0, len(moves)*200+7)
+
 	for range 200 {
 		script = append(script, moves...)
 	}
+
 	script = append(script, " Q y Qy"...)
 	tt := &testTerm{input: script}
+
 	g := NewGame(Config{Seed: 31337, Term: tt})
-	if err := g.Run(); err != nil {
+
+	err := g.Run()
+	if err != nil {
 		t.Fatalf("Run: %v", err)
 	}
+
 	if g.Playing {
 		t.Error("session did not end")
 	}
@@ -65,9 +77,12 @@ func TestRunDownStairs(t *testing.T) {
 	g.StartDaemon(DDoctor, 0, After)
 	g.Fuse(DSwander, 0, wanderTime(g), After)
 	g.StartDaemon(DStomach, 0, After)
-	if err := g.Run(); err != nil {
+
+	err := g.Run()
+	if err != nil {
 		t.Fatalf("Run: %v", err)
 	}
+
 	if g.Depth != 2 {
 		t.Errorf("depth = %d after descending, want 2", g.Depth)
 	}
@@ -79,26 +94,33 @@ func TestSaveCommandRoundTrip(t *testing.T) {
 	// The C get_str caps input at MAXINP=50 characters, so the save path
 	// must be short: work from the temp directory.
 	t.Chdir(t.TempDir())
+
 	path := "cmd.save"
 	// 'S' with no default file name goes straight to the name prompt.
 	script := "S" + path + "\n"
 	tt := &testTerm{input: []byte(script)}
 	g := NewGame(Config{Seed: 55, Term: tt})
+
 	g.FileName = "" // force the name prompt
-	if err := g.Run(); err != nil {
-		t.Fatalf("Run: %v", err)
+
+	runErr := g.Run()
+	if runErr != nil {
+		t.Fatalf("Run: %v", runErr)
 	}
 
 	h, err := Restore(path, Config{Term: &testTerm{}})
 	if err != nil {
 		t.Fatalf("Restore: %v", err)
 	}
+
 	if h.Depth != g.Depth || h.Player.Purse != g.Player.Purse {
 		t.Error("restored game does not match saved game")
 	}
 	// The restored game must be playable.
-	h.scr.term.(*testTerm).input = []byte("..Qy")
-	if err := h.Run(); err != nil {
-		t.Fatalf("restored Run: %v", err)
+	setInput(t, h, []byte("..Qy")...)
+
+	restoredErr := h.Run()
+	if restoredErr != nil {
+		t.Fatalf("restored Run: %v", restoredErr)
 	}
 }