runtime: keep scheduler_cooperative idle-wait calls direct

TestBinarySize/hifive1b/examples/echo regressed by 32 bytes after the
previous commit routed the scheduler's idle wait through a
schedulerIdleWait helper. The extra call frame + branch landed on every
non-wasip1 cooperative target, where the original direct sleepTicks /
waitForEvents calls compile to a single inlined call.

Push the wasip1-specific FD-polling logic down into the wasip1 sleepTicks
/ waitForEvents definitions themselves and revert scheduler_cooperative.go
to its pre-PR shape. Non-wasip1 targets now produce the exact same code
they did before this PR. On wasip1, sleepTicks routes through pollIO
when FD waiters are registered (unchanged behavior, just relocated).

- scheduler_cooperative.go: back to sleepTicks / waitForEvents.
- scheduler_idle_wasip1.go: defines the integrated sleepTicks +
  waitForEvents for wasip1 cooperative builds.
- scheduler_idle_wasip1_none.go: fallback definitions for wasip1 builds
  that don't use the cooperative scheduler (-scheduler=none/threads).
- runtime_wasip1.go: drop the now-relocated sleepTicks.
- wait_other.go: exclude wasip1 (covered by the two files above).
- scheduler_idle_other.go: removed; no longer needed.

Author: achille-roussel

src/runtime/runtime_wasip1.go

@@ -78,11 +78,6 @@ var (
 	sleepTicksNEvents uint32
 )
 
-func sleepTicks(d timeUnit) {
-	sleepTicksSubscription.u.u.timeout = uint64(d)
-	poll_oneoff(&sleepTicksSubscription, &sleepTicksResult, 1, &sleepTicksNEvents)
-}
-
 func ticks() timeUnit {
 	var nano uint64
 	clock_time_get(0, timePrecisionNanoseconds, &nano)

src/runtime/scheduler_cooperative.go

@@ -178,7 +178,7 @@ func scheduler(returnAtDeadlock bool) {
 					// JavaScript is treated specially, see below.
 					return
 				}
-				schedulerIdleWait(0)
+				waitForEvents()
 				continue
 			}
 
@@ -203,7 +203,7 @@ func scheduler(returnAtDeadlock bool) {
 				}
 			}
 			if timeLeft > 0 {
-				schedulerIdleWait(timeLeft)
+				sleepTicks(timeLeft)
 				if asyncScheduler {
 					// The sleepTicks function above only sets a timeout at
 					// which point the scheduler will be called again. It does

src/runtime/scheduler_idle_other.go

@@ -2,29 +2,31 @@
 
 package runtime
 
-// schedulerIdleWait is called by the cooperative scheduler when the run queue
-// is empty. timeoutTicks is the number of monotonic ticks until the next
-// sleep / timer is due, or 0 to indicate that no timer is pending and we
-// should wait until something external happens (an FD becoming ready).
+// sleepTicks is the cooperative scheduler's "wait until the next deadline"
+// primitive on wasip1. It is only called by the scheduler when the run queue
+// is empty and there's a sleeping task or pending timer due in d ticks.
 //
-// On wasip1 this routes through pollIO so that any FD waiters registered
-// via netpollAddWait participate in the same poll_oneoff call as the
-// timer. When there are no FD waiters the cheap legacy paths
-// (sleepTicks / waitForEvents) are used.
-func schedulerIdleWait(timeoutTicks timeUnit) {
-	if pollCount == 0 {
-		if timeoutTicks > 0 {
-			sleepTicks(timeoutTicks)
-			return
-		}
-		// No timer and no FDs to poll on. Genuine deadlock.
-		waitForEvents()
+// If any FD waiters are registered via netpollAddWait, this routes through
+// pollIO so the same poll_oneoff call observes both the clock subscription
+// and the FD subscriptions. With no FD waiters it falls back to the cheap
+// single-clock-subscription path.
+func sleepTicks(d timeUnit) {
+	if pollCount > 0 {
+		pollIO(ticksToNanoseconds(d))
 		return
 	}
-	if timeoutTicks > 0 {
-		pollIO(ticksToNanoseconds(timeoutTicks))
+	sleepTicksSubscription.u.u.timeout = uint64(d)
+	poll_oneoff(&sleepTicksSubscription, &sleepTicksResult, 1, &sleepTicksNEvents)
+}
+
+// waitForEvents is the cooperative scheduler's "wait until something external
+// happens" primitive. It is only called when both the run queue and the
+// timer/sleep queues are empty. With no FD waiters this is a genuine
+// deadlock; with FD waiters we block until any of them is ready.
+func waitForEvents() {
+	if pollCount > 0 {
+		pollIO(-1)
 		return
 	}
-	// FDs registered but no timer — block until any FD is ready.
-	pollIO(-1)
+	runtimePanic("deadlocked: no event source")
 }

src/runtime/scheduler_idle_wasip1.go

@@ -0,0 +1,19 @@
+//go:build wasip1 && !scheduler.tasks && !scheduler.asyncify
+
+package runtime
+
+// sleepTicks blocks the current execution context for d ticks. This is the
+// fallback used when no cooperative scheduler is configured (-scheduler=none
+// or -scheduler=threads on wasip1) and it has no FD-polling integration —
+// see scheduler_idle_wasip1.go for the cooperative variant.
+func sleepTicks(d timeUnit) {
+	sleepTicksSubscription.u.u.timeout = uint64(d)
+	poll_oneoff(&sleepTicksSubscription, &sleepTicksResult, 1, &sleepTicksNEvents)
+}
+
+// waitForEvents is only meaningful when there's an event source available.
+// Without the cooperative scheduler running poll_oneoff on FDs, wasip1 has
+// nothing to wake on, so this is a hard deadlock.
+func waitForEvents() {
+	runtimePanic("deadlocked: no event source")
+}

src/runtime/scheduler_idle_wasip1_none.go

@@ -1,4 +1,4 @@
-//go:build !tinygo.riscv && !cortexm && !(linux && !baremetal && !tinygo.wasm && !nintendoswitch) && !darwin
+//go:build !tinygo.riscv && !cortexm && !(linux && !baremetal && !tinygo.wasm && !nintendoswitch) && !darwin && !wasip1
 
 package runtime