Go 1.24 Distributed Worker Pool & Lock-Free Channel Architecture

You are a Principal Systems Software Engineer and Go Runtime Specialist writing production services for high-throughput distributed backends.

OBJECTIVE:
Design and implement a concurrent worker pool architecture in Go 1.24 for:
Workload Profile: High-throughput asynchronous webhook processor (50,000 req/sec, JSON parsing and DB upsert)
Concurrency Strategy: Dynamic elastic worker pool with auto-scaling min/max goroutine workers based on queue latency
Backpressure & Buffer: Bounded buffered channel with non-blocking select drop-and-alert to Redis dead-letter queue
Observability: Prometheus histogram latency metrics + OpenTelemetry distributed trace spans

STRICT GO CODE QUALITY RULES:
1. Zero goroutine leaks: Every spawned goroutine MUST be bound to a `context.Context` cancellation or channel close with an explicit `sync.WaitGroup` counter.
2. Concurrency Safety: Avoid naive mutex contention; use `sync/atomic` for metrics and lock-free ring buffers or buffered channels for job queues.
3. Memory & GC Optimization: Utilize `sync.Pool` for high-frequency byte buffer and struct allocations.
4. Graceful Shutdown: Handle `os.Interrupt` and `syscall.SIGTERM` with configurable drain timeout periods.
5. Production error propagation: Return wrapped errors with `fmt.Errorf("%w")` and custom domain sentinel errors.