perf: proto schema thinning (dual-variant build tags) to cut decode GC

[jfberry]

What & why

Golbat decodes protobuf from game clients but only reads ~420 of the POGO schema's ~15,800 fields. Every unread field is still decoded into allocated Go structs on every message — a large source of GC pressure (GMO decoding dominates allocation).

This PR makes schema thinning a working build option: a regenerated pogo variant that keeps only the fields Golbat reads. Removed fields keep their field numbers, so they become unknown fields on the wire and — paired with DiscardUnknown — are skipped instead of decoded. It's the static, dependency-free equivalent of lazy decoding: the decode cost of ~97% of the schema disappears, with byte-identical decoded values for the fields we do read.

How it ships — two build-tag variants

The .proto can't be redistributed (license), so the generated Go ships in two mutually-exclusive variants:

File	Build tag	Used by
pogo/vbase.pb.go	//go:build !thin	contributors, gopls, plain go build — full field discovery
pogo/vbase.thin.pb.go	//go:build thin	make golbat / Docker — the production win

Same package, same Go type names, only one compiled at a time → no proto-registry clash.

• make golbat and the Dockerfile now build -tags thin (end users get the win by default).
• make golbat-full and plain go build stay full (contributors / IDE).

Why it's safe

• Field numbers preserved → wire compatibility unchanged; kept fields decode identically.
• Golbat is read-only against client protos and never re-marshals them (the analyzer confirms — the only reflective escapes are one cosmetic .String() in a log and three proto.Marshal calls in test fixtures). So dropping unread fields can't lose data.
• DiscardUnknown is included (it's coupled to thinning: without it, protobuf-go retains each removed field as a raw-bytes unknown blob, clawing back the win). decode.go's unmarshalClientProto routes every inbound client decode through DiscardUnknown; Golbat's own internal proto (GolbatInternal) intentionally keeps plain proto.Unmarshal.

The regeneration pipeline (scripts/thin.sh, maintainer-side)

Needs only protoc + Go — not the licensed .proto:

1. tools/dumpdesc → full FileDescriptorSet, extracted from the already-compiled pogo.File_vbase_proto (so the thin variant is a guaranteed faithful subset of what vbase.pb.go ships).
2. tools/protofields → the exact (message, field) set Golbat's code accesses (type-precise via go/types; includes _test.go so the suite runs under -tags thin).
3. tools/protofields/prototrim → trims the descriptor set to that set, preserving field numbers + oneof structure.
4. protoc --descriptor_set_in → pogo/vbase.thin.pb.go.

Deterministic (repeated runs are byte-identical). Rerun whenever vbase.pb.go is regenerated or field usage changes.

Correctness gate

The differential is elegant: the full test suite compiled -tags thin IS the full-vs-thin comparison — the same tests decode real protos and assert entity outcomes, so passing under both tags proves thin decodes identically. CI should require all four:

go build ./...            go test ./...             # full
go build -tags thin ./...  go test -tags thin ./...  # thin (differential)

A contributor who reads a not-yet-thinned field gets a clean -tags thin compile error naming the exact field — never a silent wrong decode.

Reviewing

The two generated pogo/*.pb.go files are large; the reviewable change is the ~700 lines of tooling + wiring: tools/protofields/, tools/dumpdesc/, scripts/thin.sh, decode*.go (DiscardUnknown), Makefile, Dockerfile. See tools/protofields/README.md for the design.