Add retry-safe live Slack contract tests

[alex-clickhouse]

Part 4 of the Slack channel stack. Adds tests that run against a real Slack
workspace, and the harness they need to be trustworthy. Everything here skips
unless the credentials are set, so a fork and the ordinary suite are
unaffected.

Stack

1. Shared chat-channel foundations #404: shared chat-channel foundations
2. Slack channel with coherent runtime and access guardrails #403: Slack channel, access guardrails, and runtime ownership
3. Deliver notifications through Slack #405: Slack notification delivery
4. Add retry-safe live Slack contract tests #406: real-Slack contract tests and diagnostics (this PR)

What only a real workspace can answer

The unit tests prove the channel is self-consistent against a fake. They
cannot tell you whether Slack accepts a Block Kit payload, whether an emoji
short name exists, whether users.info withholds an email rather than
failing, or whether an event survives the whole trip from a keystroke to an
InboundMessage. That is what these cover.

Two facts about Slack that shape the harness

Slack gives each event to exactly one of an app's open connections. Two
test runs at once therefore steal each other's events rather than both seeing
them. So CI serializes on the workspace, not on the branch: the concurrency
group is a fixed name, and an already-running job is allowed to finish rather
than being cancelled, because cancelling it would leave its events
unacknowledged.

Slack retries anything left unacknowledged, on a schedule: immediately,
then at about +60s and +5min. A run that ends with unacknowledged events
therefore poisons the next run, which sees them arrive as if they were its
own. Two consequences shape the layout:

• The outbound tests post, edit, upload, and delete. Each of those produces an
  event. They run with a socket open that acknowledges and discards
  everything, so their own traffic never comes back later.
• The inbound tests are the only thing that interprets events, and they run in
  a separate process so the two roles cannot overlap.

Making the tests mean something

A refusal test has to prove the event arrived. Waiting and finding the
router empty does not distinguish a guardrail that refused the message from an
event Slack never delivered, one it handed to another connection, or one the
harness dropped as stale. Each refusal test now waits for the envelope to
reach the channel first, then asserts nothing came out of it, and says which
of the two failed. Without that, deleting the access policy altogether left
these tests green.

Old events are dropped, in the harness only. A test only ever waits for a
message it just posted, so a retried envelope or one older than the delivery
timeout belongs to an earlier test or an earlier run. Production does the
opposite on purpose: handling a retry is how a message survives a restart.

Event age is measured on Slack's clock. The age of an event is the gap
between a timestamp Slack wrote and a reading of the local clock, which are
two different clocks. A runner drifted ahead of Slack by more than the cutoff
would call every fresh event stale and drop it, and on the refusal tests that
reads as a guardrail working. The offset is measured from a probe's own
timestamp instead of assumed.

Readiness is a fresh event, not a connected socket. While retries are
outstanding a newly opened socket is deaf to new events for 20 to 30 seconds.
Setup posts a probe and waits for that message's own timestamp to arrive
unretried, re-probing until it lands, then waits for its deletion event too.
That makes the round trip a fence: once it returns, it has left nothing of its
own unacknowledged.

Cleaning up after itself

The suite deletes the messages, reactions, and files it creates. Messages go
through chat.delete; a file is not a message, so uploads are tracked by id
and removed with files.delete. Items are recorded before the assertions that
could fail, so a failure part way through does not leave data behind. An
interrupted run can still leave some, which is why the docs call for a
throwaway workspace.

Diagnostics

The harness emits one-line SLACK_LIVE JSON records for connections, probes,
retries, event ages and types, and per-socket summaries. Secrets reach them
through a field allow-list, and CI scopes the tokens to the two steps that
need them so GitHub masks them as well.

docs/testing-slack.md covers the scratch-workspace setup, the required
scopes, and the two-process layout.