fix(sched): closed the kill-before-block race in all blocking paths

[FlareCoding]

Summary

• force_wake_for_kill only acts on tasks already sleeping or BLOCKED, so a kill landing while the victim was still entering a block was silently lost — delayed until natural wakeup for sleeps, or until an unrelated wake for futexes. This is the root cause of the kill-suite CI flakes.
• Blocking now uses a sched-owned protocol — prepare_to_block_task / block_task_interrupted_by_kill / cancel_block_task — adopted by the interruption-capable sites (sleep, futex, poll). poll_wait already hand-rolled exactly this pattern; its bespoke copy is deleted in favor of the shared one, which also adds the store-load fence pairing the hand-rolled version lacked.
• Wait-queue waits keep their existing semantics (callers are not kill-aware; aborting there would turn kill-unaware wait loops into hot spins). wait() now uses the atomic-release state transition and both docs state the contract honestly. A wait_killable variant plus caller audit is explicit follow-up work.
• Proof: new deterministic regression test (kill_before_sleep_aborts_sleep) fails on the unfixed kernel at exactly the 5 s natural expiry and passes with the fix; full suite 510/510 across repeated runs on both architectures.

---

Note

High Risk
Changes core scheduler blocking, kill delivery, and synchronization primitives (sleep, futex, poll); incorrect fencing or unwind logic could cause lost wakeups, stuck tasks, or spurious EINTR.

Overview
Fixes a race where force_wake_for_kill could miss a task still entering a block, so kills were delayed until natural wakeup (or unrelated wakes). The scheduler now owns a shared prepare → kill-check → cancel blocking protocol with SEQ_CST fences pairing force_wake_for_kill and block_task_interrupted_by_kill.

Sleep, futex wait, and poll_wait adopt that protocol: they unwind timers/waiters and return without yielding when a kill is seen at the commit point. poll_wait drops its local abort helper in favor of the shared cancel_block_task. sync::wait only switches to atomic prepare_to_block_task; docs state it is not kill-interruptible without caller loops on is_kill_pending().

Tests use wall-clock spin timeouts and wait_until_blocked instead of brief_delay, plus a new kill_before_sleep_aborts_sleep regression for pre-enqueue kills.

^{Reviewed by Cursor Bugbot for commit 520abb2. Bugbot is set up for automated code reviews on this repo. Configure here.}

[cursor]

Current version of PR was reviewed by /review-bugbot on Jul 27, 20:32 PDT. It flagged 0 findings.

^{Bugbot on commit aa0aff5 is skipped.}

[cursor]

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, have a team admin enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit dcc3660. Configure here.}