docs(reference): document receive_coop empty-batch and lock behavior

- Add an "empty tick windows are auto-finished" note: receive_coop()
  closes empty batches internally, so callers polling a quiet queue do
  not need to ack a batch_id. This is a meaningful divergence from
  receive() and was previously undocumented.
- Add a throughput note explaining that cooperative allocation
  serializes on a FOR UPDATE of the coop_main row, so undersized
  batches and short tick periods make the main row a hotspot.
- Drop the "in PgQue 0.2" version tag from the experimental marker per
  the docs rule ("no concrete version tags in README/docs").

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: NikolayS

docs/reference.md

@@ -148,7 +148,7 @@ perform pgque.nack(msg.batch_id, msg, interval '5 minutes', 'validation failed')
 
 ## Cooperative consumers / subconsumers
 
-**Experimental in PgQue 0.2.** Function names, edge-case behavior, and client API shape may change before this feature is marked stable. Do not use this as the only processing path for critical workloads without idempotent handlers and stale-worker takeover tests.
+**Experimental.** Function names, edge-case behavior, and client API shape may change before this feature is marked stable. Do not use this as the only processing path for critical workloads without idempotent handlers and stale-worker takeover tests.
 
 Cooperative consumers let several subconsumers share one logical consumer cursor. The main consumer row (`sub_role = 'coop_main'`) owns the group cursor; member rows (`sub_role = 'coop_member'`) own active batches. The feature is bundled in the default SQL install, but downgrade after creating subconsumers is unsupported unless subconsumers are unregistered first.
 
@@ -168,7 +168,12 @@ Grant: `pgque_reader`. Source: `sql/pgque-api/cooperative_consumers.sql`.
 
 Receives messages for one subconsumer. `max_return` must be >= 1. `dead_interval` enables stale-batch takeover from another inactive member; takeover allocates a fresh `batch_id`, so old tokens cannot ack/nack the new owner's state. The cooperative group is a trust boundary: callers allowed to use the same `(queue, consumer)` can steal stale batches from each other by design, so do not share one cooperative group across mutually untrusted workers.
 
+**Empty tick windows are auto-finished.** When the current batch's tick window holds no events, `receive_coop()` calls `finish_batch` internally and returns the empty set. Callers polling a quiet queue do not see (and do not need to ack) a `batch_id`; this differs from `receive()`, which still returns an active batch token even when the result set is empty.
+
 **Batch-ownership caveat.** As with `receive()`, `max_return` limits only returned rows; `ack(batch_id)` advances the cooperative cursor past the whole underlying batch. Use `max_return >= ticker_max_count` or consume the full batch before acking.
+
+**Throughput note.** Cooperative allocation serializes on a `FOR UPDATE` of the `coop_main` subscription row, so many workers polling tiny batches contend on a single hot row. If you scale workers, also tune `ticker_max_count` and tick cadence so each batch is large enough to amortize the lock.
+
 Grant: `pgque_reader`. Source: `sql/pgque-api/cooperative_consumers.sql`.
 
 #### `pgque.next_batch(queue text, consumer text, subconsumer text, dead_interval interval default null) → bigint`