perf(controller): reconcile tasks concurrently within one worker

[anzal1]

Implements the proposal in #384. Opening it so the code is easy to review; happy to change the approach or the default.

Problem

Worker.Run handled events one at a time and ax-controller runs a single worker, so a controller process is bounded by the latency of one reconcile: a chain of sequential Substrate RPCs plus, for a cold workspace, up to WorkspaceReadyTimeout (15s) of /readyz polling. Throughput only scaled by adding pods.

Change

• Worker.Concurrency, exposed as ax-controller --concurrency (default 16). Values below 1 mean 1, so library callers that don't set it keep sequential behaviour.
• Events are sharded to slots by an FNV hash of atespace/name. Events for one task always go to the same slot, in order, so a task never reconciles concurrently with itself; unrelated tasks run in parallel.
• Each slot has a bounded queue (64), so a task with several queued events doesn't stall the other slots. The reader blocks only when a slot's queue is full.
• Events are still acknowledged only after processing. On shutdown the reader stops, and in-flight and queued events finish before Run returns.

Benchmark

BenchmarkWorkerThroughput uses a fake Substrate at 10ms per RPC and a 200ms readiness poll standing in for the 15s default, 64 tasks per run, rebased on current main:

concurrency	warm tasks/s	cold tasks/s
1	18.3	3.9
4	68.3	14.8
16	191.4	41.8
64	379.2	83.4

go test ./internal/controller -run '^$' -bench WorkerThroughput -benchtime 1x

Tests

TestWorkerConcurrencyKeepsTasksSerial queues three revisions of each of 16 tasks back to back and asserts that no task ever has two Substrate calls in flight, and that the batch finishes well under the serial time. I checked that it fails when sharding is replaced with round-robin (3 concurrent calls for one task) and when concurrency is 1 (too slow). make test and go test -race ./... pass.

Open questions

• Is 16 a reasonable default, or would you prefer 1 (opt-in) until this has run against a real Substrate?
• A natural follow-up is merging duplicate reconcile events for the same task while one is queued, since a reconcile always reads the latest spec.