ateredis: encode Actor/Worker records as binary protobuf (#307)

[Frederick F. Kautz IV (fkautz)]

Summary

Switch the on-the-wire encoding of Actor and Worker records in the Valkey
state store from protojson to binary protobuf. This roughly halves per-record
RAM and is about 4x faster to encode, which extends runway toward the
1-billion-record target. The change is scoped to the resident Actor/Worker
records, as described in #307.

This is a clean cutover with no migration path. Since this is pre-alpha with no
production data, the keyspace is flushed on deploy. protojson and binary
protobuf cannot decode each other, so it is not safe as a rolling update across
the cutover. Deploy by stopping the replicas, flushing the keyspace, then
starting the new version.

Changes

• Write path: proto.Marshal for Actor and Worker (Create and Update).
• Read path: proto.Unmarshal (Get, Update, Delete, List).
• The optimistic-concurrency version check stays in Go and compares the decoded
  version field rather than the raw bytes, so the WATCH/MULTI paths are
  unaffected and the encoding is never inspected from Redis Lua.
• Added key-identity guards to the list paths (fetchActors and ListWorkers).
  Unlike protojson, proto.Unmarshal accepts an empty byte slice and returns a
  zero-valued message without an error. GetActor and GetWorker already
  rejected that case via their identity checks, and the list paths now do too.

Out of scope (intentionally still protojson)

• Atespace records, which are low cardinality and use negligible RAM at scale.
• The worker-change pub/sub payload, which is ephemeral and never persisted.

Testing

• Unit (miniredis): a binary-on-the-wire assertion for both record types, which
  catches an accidental revert to protojson, plus rejection of empty, corrupt,
  and identity-mismatched values across both the Get and List paths.
• Integration (-tags integration): real-cluster round-trip for both types,
  an optimistic-concurrency conflict for both types, and a binary-safe lock test
  using a token with a NUL byte. These skip unless ATE_TEST_REDIS_ADDR points
  at a dedicated, empty cluster, and they refuse to run against a non-empty or
  non-cluster server.

Verified locally against a single-node Valkey 9.1.0 cluster:

ATE_TEST_REDIS_ADDR=127.0.0.1:7300 go test -tags integration \
    ./cmd/ateapi/internal/store/ateredis/

All unit and integration tests pass, and go vet and gofmt are clean. There
is no change to store.Interface, and existing store tests pass unmodified.

Closes #307.

[Julian Gutierrez Oschmann (juli4n)]

I don't know how relevant this comment is:

"Binary protobuf roughly halves per-record memory versus protojson and
// is ~4x faster to encode; the optimistic-concurrency version check stays in Go
Comment view// (comparing the decoded version field, never the raw bytes), so the encoding is
// never inspected from Redis lua."

Looks more like a point in time commit message than package documentation (e.g. 4x faster than what?).

I would just remove it or turn it into a message that justifies why we use binary proto encoding instead of JSON / textproto.

[Julian Gutierrez Oschmann (juli4n)]

I think we should be consistent and use the same encoding across all resources. Over time we will add more resources, and having to think about which ones are in which encoding will add significant cognitive burden.

[Frederick F. Kautz IV (fkautz)]

Not a problem, I'll move the others over too.