fix: isolate scheduled wake dispatches

[mostlydev]

Summary

• dispatch due runner targets concurrently so one slow wake cannot stall unrelated targets or the minute loop
• preserve strict FIFO ordering per runner target across scheduled ticks and manual fires
• coalesce overlapping slots per invocation, keep next-fire state monotonic, and return HTTP 409 for duplicate manual fires
• treat queue, lookup, and execution cancellation neutrally and drain active scheduler dispatches during shutdown

Boundary

This stays entirely in claw-api scheduler transport/state. It adds no runner prompt behavior, downstream wrapper, or cllama feature. PR #346 remains draft and should depend on this fairness correction before extending a Hermes wake budget.

Verification

• git diff --check
• DOCKER_HOST=unix:///tmp/clawdapus-no-docker.sock go test -count=1 ./...
• DOCKER_HOST=unix:///tmp/clawdapus-no-docker.sock go vet ./...
• go test -race -count=20 ./cmd/claw-api
• independent adversarial review found no blocking correctness issue

Closes #347

[mostlydev]

Pushed two scoped corrections to this branch (2c8ec25) after independent adversarial review. Full review notes are in the talking-stick room; summary here.

No correctness bug found. Verified independently rather than trusting CI: go test -race -count=20 ./cmd/claw-api clean, lock order is consistently s.mu -> q.mu with no inversion anywhere, the reservation state machine handles waiting/granted/released/canceled including the double-cancel and cancel-while-granted paths, and dispatchWG.Add happens under s.mu before goroutine launch so the shutdown drain is sound.

Correction 1 — coalesced slots were audit-invisible (requirement 5 of #347).

tick() advanced and persisted nextFireUTC for a suppressed entry and logged overlap-suppressed, but wrote nothing to InvocationState. Proved with a test: three due slots with one execution left LastStatus=fired, LastFiredAt=T0, NextFireAt=T0+3m, ConsecutiveFailures=0 — byte-identical to a schedule that only ever had one slot due. cmd/clawdash/schedule_page.go and claw api schedule read only that state, so a schedule quietly firing at a third of its cron rate rendered as perfectly healthy, with the only evidence in container logs.

The suppression itself is correct and intended — the gap was that it left no operator-visible trace. Fix keeps the existing model rather than inventing a new one:

• cumulative suppressed_slots + last_suppressed_at on InvocationState, written in the same state update that advances next-fire, so a completing wake cannot erase the record (regression-tested)
• deliberately did not overload LastSkippedAt / LastStatus — skipped already means the when: guard declined the slot, which is a different thing from a dropped slot
• the log line now carries the dropped slot timestamp
• clawdash schedule card gains a note; a clean dispatch still produces no note (both directions tested)

This matters specifically because #346 gives Hermes a 2-minute budget, which exceeds many cron cadences and makes coalescing an ordinary occurrence rather than an edge case.

Correction 2 — dead select arm. Run()'s case <-s.stopCtx.Done() is unreachable: stopCancel() is only called by stopScheduledDispatches(), whose only caller is Run()'s own ctx.Done branch, which returns immediately after. Removed the arm. stopCtx itself stays — FireNow legitimately uses context.AfterFunc(s.stopCtx, cancel) to cancel in-flight manual fires at shutdown.

Withdrawn finding, recorded for honesty. I first measured "6 due slots produce 1 dispatch" and was going to report it as a regression. It is not one. Master's tick is synchronous, so a slow wake blocks the loop and later slots coalesce there too; my harness drove six back-to-back ticks in a way master structurally cannot. This PR does not reduce executed wake count, it decouples targets. Withdrawn.

Verification on the updated branch: go test ./... (all packages), go vet ./..., go test -race -count=20 ./cmd/claw-api, git diff --check — all pass. Changelog edit stays inside ## Unreleased; no pins, badges, nav, or submodule movement.