runtime,internal/poll,loader: wasip2 pollable poll-integration + TCP I/O

[achille-roussel]

Stacked on #5386. Mirrors the wasip1 work for wasip2. The cooperative scheduler's idle path now calls wasi:io/poll.Poll over a combined list of (clock pollable, registered pollables) instead of blocking the wasm module on a single monotonic-clock subscription, so goroutines doing TCP I/O can park while the scheduler runs other goroutines.

End to end:

$ tinygo build -target=wasip2 -o tcpecho_wasip2.wasm ./tcpecho_wasip2.go
$ wasmtime run -Sinherit-network -Stcp ./tcpecho_wasip2.wasm &
listening on 127.0.0.1:9999
tick 1
tick 2
tick 3

$ echo hello | nc 127.0.0.1 9999
hello                                    # echoed by the wasm

Two concurrent nc clients both echo while the ticker keeps progressing — the cooperative scheduler keeps running goroutines parked on sock_recv via the new pollable registry.

How it works

Wasip2's polling primitive is wasi:io/poll.Poll(list<own<pollable>>) -> list<u32> taking a list of pollable resource handles. Each blocking wasi operation has a subscribe() that yields a pollable.

TCPConn.Read / Write   ─would-block─►  internal/poll registry  ─►  task.Pause()
                                                │
                                                ▼
                       scheduler idle  ──►  pollIO(timeoutNs)
                                                │
                                                ├─ build pollables: [clock?, p1, p2, …]
                                                ├─ wasi:io/poll.Poll(...)
                                                └─ wake matched tasks → run queue

The wasip2 path mirrors the wasip1 PR's structure file-for-file:

wasip1	wasip2
runtime/netpoll_wasip1.go (FD-keyed poll_oneoff registry)	runtime/netpoll_wasip2.go (pollable-keyed wasi:io/poll.Poll registry)
runtime/scheduler_idle_wasip1.go (cooperative sleepTicks routes via pollIO)	runtime/scheduler_idle_wasip2.go (cooperative sleepTicks routes via pollIO)
runtime/scheduler_idle_wasip1_none.go (non-coop fallback)	runtime/scheduler_idle_wasip2_none.go (non-coop fallback)
internal/poll/fd_wasip1.go (FD type)	internal/poll/fd_wasip2.go (WasipNFD over (TcpSocket, InputStream, OutputStream))
syscall/syscall_libc_wasip1.go park-on-EAGAIN	(not needed — wasip2 wasi calls return would-block directly into internal/poll)

What's added

• src/runtime/netpoll_wasip2.go — pollable-keyed pollDesc registry, pollIO(timeoutNs) building one combined wasi:io/poll.Poll call (clock + active pollables), linkname-exposed wake helpers (runtime_netpoll_addpollable_wasip2 / done / pdfired / wake). Three timing cases handled like wasip1's pollIO.
• src/runtime/scheduler_idle_wasip2.go + scheduler_idle_wasip2_none.go — cooperative-variant sleepTicks / waitForEvents that route through pollIO when pollables are registered; non-coop fallback uses monotonicclock.Block. Matches the wasip1 file split.
• src/runtime/runtime_wasip2.go — sleepTicks moved out (now per-config in scheduler_idle_wasip2*.go).
• src/runtime/wait_other.go — build tag tightened to exclude wasip2.
• src/internal/poll/fd_wasip2.go — WasipNFD wraps (TcpSocket, InputStream, OutputStream). DialTCPWasip2, ListenTCPWasip2, Accept, Read, Write, Close, SetDeadline*. Each blocking op tries the wasi call, on would-block subscribes, parks via runtime_netpoll_addpollable_wasip2 + task.Pause, on resume drops pollable + retries. Deadline-aware variants use parkUntil + time.AfterFunc + runtime_netpoll_wake_wasip2. Linkname-friendly Wasip2TCP{Listen,Dial,Accept,Read,Write,Close,SetDeadline} wrappers for test / future net callers.
• src/internal/poll/errors_wasip.go — error sentinels (ErrFileClosing, ErrNetClosing, ErrDeadlineExceeded, ErrNoDeadline) extracted from fd_wasip1.go to a wasip1 || wasip2 shared file.
• src/os/poll_link_wasip2.go — pulls internal/poll into the wasip2 build (no-op blank import with justifying comment for the lint check).
• loader/goroot.go — listGorootMergeLinks now filters TinyGo files by //go:build constraints (via go/build.Context.MatchFile) before deciding "TinyGo owns this directory". Files that don't match the current target no longer cause upstream Go files at the same level to be dropped. Unblocks per-target overrides for follow-up work without disturbing wasip1.

Non-goals (deferred)

• net.Listen("tcp", ...) / net.Dial("tcp", ...) on wasip2 via the standard net package. Upstream Go's net doesn't currently build for wasip2 because its cgo_linux.go reaches for netdb.h even though TinyGo doesn't enable cgo. Bringing up upstream net on wasip2 (either by filtering its cgo files from the merge or providing a TinyGo-native net override) is its own piece of work — the linkname-friendly TCP helpers in this PR are the foundation. The synthetic test program calls them directly.
• UDP / PacketConn and DNS resolution. Same shape will work (wasi:sockets/udp, wasi:sockets/ip-name-lookup) but not in scope here.

Wasip1 regression sweep: tcpecho.wasm from #5386 still passes (echo hi | nc 127.0.0.1 9998 round-trip + concurrent clients); time.Sleep / parkfile / parksynth unchanged.