The shared socket code (crates/wasi/src/sockets/*) was modeled after
the p2 interface, with p3 bindings papering over the differences, and
some functionality duplicated between p2/* and p3/*. This has already
caused bugs in the past (bytecodealliance#13631).

Since the p3 interface is strictly a superset of p2, invert that
relationship: the shared code becomes the canonical (p3-shaped)
implementation, and p3's bindings are now a thin wrapper around it.
All p2-only behavior & state moves into the p2 bindings layer instead
(artificial restrictions like disallowing implicit binds, and the
start/finish async bookkeeping).

Other notable changes:

- Each socket now stores its own copy of the WasiCtx's
  socket_addr_check at creation time, so all permission checks live in
  the shared socket code instead of being split across p2/p3. The p2
  Network resource is now just an unforgeable capability token.
- Removed the Bound state; whether a socket is bound is now determined
  lazily via getsockname/local_addr instead of tracked explicitly. This
  lets UdpSocket::send return a future that runs to completion
  independently, without needing to rendezvous back with the socket to
  update its state.
- Updated SocketAddrUse: added TcpListen, TcpAccept, UdpReceive;
  replaced UdpConnect with UdpSend/UdpReceive checks, since connecting
  a UDP socket is just a local operation that sets the default remote
  address and does no I/O of its own. connect() now succeeds as long
  as either send or receive is permitted for the address.
- Tcp/UdpSocket::connect now also check the implicit bind the OS
  performs when connecting an unbound socket, matching the check
  already done for explicit binds.

Added test coverage for previously-untested behavior:

- test_udp_disconnect_local_address (p2 & p3): disconnecting a UDP
  socket keeps it bound.
- test_udp_send_receive_multiple (p2): bulk send/receive of multiple
  datagrams in a single call over a connected stream().
- test_udp_receive_after_connect (p2): datagrams from other peers
  queued before connecting are filtered out once connected.

The shared socket code (crates/wasi/src/sockets/*) was modeled after
the p2 interface, with p3 bindings papering over the differences, and
some functionality duplicated between p2/* and p3/*. This has already
caused bugs in the past (bytecodealliance#13631).

Since the p3 interface is strictly a superset of p2, invert that
relationship: the shared code becomes the canonical (p3-shaped)
implementation, and p3's bindings are now a thin wrapper around it.
All p2-only behavior & state moves into the p2 bindings layer instead
(artificial restrictions like disallowing implicit binds, and the
start/finish async bookkeeping).

Other notable changes:

- Each socket now stores its own copy of the WasiCtx's
  socket_addr_check at creation time, so all permission checks live in
  the shared socket code instead of being split across p2/p3. The p2
  Network resource is now just an unforgeable capability token.
- Removed the Bound state; whether a socket is bound is now determined
  lazily via getsockname/local_addr instead of tracked explicitly. This
  lets UdpSocket::send return a future that runs to completion
  independently, without needing to rendezvous back with the socket to
  update its state.
- Updated SocketAddrUse: added TcpListen, TcpAccept, UdpReceive;
  replaced UdpConnect with UdpSend/UdpReceive checks, since connecting
  a UDP socket is just a local operation that sets the default remote
  address and does no I/O of its own. connect() now succeeds as long
  as either send or receive is permitted for the address.
- Tcp/UdpSocket::connect now also check the implicit bind the OS
  performs when connecting an unbound socket, matching the check
  already done for explicit binds.

Added test coverage for previously-untested behavior:

- test_udp_disconnect_local_address (p2 & p3): disconnecting a UDP
  socket keeps it bound.
- test_udp_send_receive_multiple (p2): bulk send/receive of multiple
  datagrams in a single call over a connected stream().
- test_udp_receive_after_connect (p2): datagrams from other peers
  queued before connecting are filtered out once connected.

The shared socket code (crates/wasi/src/sockets/*) was modeled after
the p2 interface, with p3 bindings papering over the differences, and
some functionality duplicated between p2/* and p3/*. This has already
caused bugs in the past (bytecodealliance#13631).

Since the p3 interface is strictly a superset of p2, invert that
relationship: the shared code becomes the canonical (p3-shaped)
implementation, and p3's bindings are now a thin wrapper around it.
All p2-only behavior & state moves into the p2 bindings layer instead
(artificial restrictions like disallowing implicit binds, and the
start/finish async bookkeeping).

Other notable changes:

- Each socket now stores its own copy of the WasiCtx's
  socket_addr_check at creation time, so all permission checks live in
  the shared socket code instead of being split across p2/p3. The p2
  Network resource is now just an unforgeable capability token.
- Removed the Bound state; whether a socket is bound is now determined
  lazily via getsockname/local_addr instead of tracked explicitly. This
  lets UdpSocket::send return a future that runs to completion
  independently, without needing to rendezvous back with the socket to
  update its state.
- Updated SocketAddrUse: added TcpListen, TcpAccept, UdpReceive;
  replaced UdpConnect with UdpSend/UdpReceive checks, since connecting
  a UDP socket is just a local operation that sets the default remote
  address and does no I/O of its own. connect() now succeeds as long
  as either send or receive is permitted for the address.
- Tcp/UdpSocket::connect now also check the implicit bind the OS
  performs when connecting an unbound socket, matching the check
  already done for explicit binds.

Added test coverage for previously-untested behavior:

- test_udp_disconnect_local_address (p2 & p3): disconnecting a UDP
  socket keeps it bound.
- test_udp_send_receive_multiple (p2): bulk send/receive of multiple
  datagrams in a single call over a connected stream().
- test_udp_receive_after_connect (p2): datagrams from other peers
  queued before connecting are filtered out once connected.

The shared socket code (crates/wasi/src/sockets/*) was modeled after
the p2 interface, with p3 bindings papering over the differences, and
some functionality duplicated between p2/* and p3/*. This has already
caused bugs in the past (bytecodealliance#13631).

Since the p3 interface is strictly a superset of p2, invert that
relationship: the shared code becomes the canonical (p3-shaped)
implementation, and p3's bindings are now a thin wrapper around it.
All p2-only behavior & state moves into the p2 bindings layer instead
(artificial restrictions like disallowing implicit binds, and the
start/finish async bookkeeping).

Other notable changes:

- Each socket now stores its own copy of the WasiCtx's
  socket_addr_check at creation time, so all permission checks live in
  the shared socket code instead of being split across p2/p3. The p2
  Network resource is now just an unforgeable capability token.
- Removed the Bound state; whether a socket is bound is now determined
  lazily via getsockname/local_addr instead of tracked explicitly. This
  lets UdpSocket::send return a future that runs to completion
  independently, without needing to rendezvous back with the socket to
  update its state.
- Updated SocketAddrUse: added TcpListen, TcpAccept, UdpReceive;
  replaced UdpConnect with UdpSend/UdpReceive checks, since connecting
  a UDP socket is just a local operation that sets the default remote
  address and does no I/O of its own. connect() now succeeds as long
  as either send or receive is permitted for the address.
- Tcp/UdpSocket::connect now also check the implicit bind the OS
  performs when connecting an unbound socket, matching the check
  already done for explicit binds.

Added test coverage for previously-untested behavior:

- test_udp_disconnect_local_address (p2 & p3): disconnecting a UDP
  socket keeps it bound.
- test_udp_send_receive_multiple (p2): bulk send/receive of multiple
  datagrams in a single call over a connected stream().
- test_udp_receive_after_connect (p2): datagrams from other peers
  queued before connecting are filtered out once connected.

The shared socket code (crates/wasi/src/sockets/*) was modeled after
the p2 interface, with p3 bindings papering over the differences, and
some functionality duplicated between p2/* and p3/*. This has already
caused bugs in the past (bytecodealliance#13631).

Since the p3 interface is strictly a superset of p2, invert that
relationship: the shared code becomes the canonical (p3-shaped)
implementation, and p3's bindings are now a thin wrapper around it.
All p2-only behavior & state moves into the p2 bindings layer instead
(artificial restrictions like disallowing implicit binds, and the
start/finish async bookkeeping).

Other notable changes:

- Each socket now stores its own copy of the WasiCtx's
  socket_addr_check at creation time, so all permission checks live in
  the shared socket code instead of being split across p2/p3. The p2
  Network resource is now just an unforgeable capability token.
- Removed the Bound state; whether a socket is bound is now determined
  lazily via getsockname/local_addr instead of tracked explicitly. This
  lets UdpSocket::send return a future that runs to completion
  independently, without needing to rendezvous back with the socket to
  update its state.
- Updated SocketAddrUse: added TcpListen, TcpAccept, UdpReceive;
  replaced UdpConnect with UdpSend/UdpReceive checks, since connecting
  a UDP socket is just a local operation that sets the default remote
  address and does no I/O of its own. connect() now succeeds as long
  as either send or receive is permitted for the address.
- Tcp/UdpSocket::connect now also check the implicit bind the OS
  performs when connecting an unbound socket, matching the check
  already done for explicit binds.

Added test coverage for previously-untested behavior:

- test_udp_disconnect_local_address (p2 & p3): disconnecting a UDP
  socket keeps it bound.
- test_udp_send_receive_multiple (p2): bulk send/receive of multiple
  datagrams in a single call over a connected stream().
- test_udp_receive_after_connect (p2): datagrams from other peers
  queued before connecting are filtered out once connected.

* Unify the p2 & p3 socket implementations

The shared socket code (crates/wasi/src/sockets/*) was modeled after
the p2 interface, with p3 bindings papering over the differences, and
some functionality duplicated between p2/* and p3/*. This has already
caused bugs in the past (bytecodealliance#13631).

Since the p3 interface is strictly a superset of p2, invert that
relationship: the shared code becomes the canonical (p3-shaped)
implementation, and p3's bindings are now a thin wrapper around it.
All p2-only behavior & state moves into the p2 bindings layer instead
(artificial restrictions like disallowing implicit binds, and the
start/finish async bookkeeping).

Other notable changes:

- Each socket now stores its own copy of the WasiCtx's
  socket_addr_check at creation time, so all permission checks live in
  the shared socket code instead of being split across p2/p3. The p2
  Network resource is now just an unforgeable capability token.
- Removed the Bound state; whether a socket is bound is now determined
  lazily via getsockname/local_addr instead of tracked explicitly. This
  lets UdpSocket::send return a future that runs to completion
  independently, without needing to rendezvous back with the socket to
  update its state.
- Updated SocketAddrUse: added TcpListen, TcpAccept, UdpReceive;
  replaced UdpConnect with UdpSend/UdpReceive checks, since connecting
  a UDP socket is just a local operation that sets the default remote
  address and does no I/O of its own. connect() now succeeds as long
  as either send or receive is permitted for the address.
- Tcp/UdpSocket::connect now also check the implicit bind the OS
  performs when connecting an unbound socket, matching the check
  already done for explicit binds.

Added test coverage for previously-untested behavior:

- test_udp_disconnect_local_address (p2 & p3): disconnecting a UDP
  socket keeps it bound.
- test_udp_send_receive_multiple (p2): bulk send/receive of multiple
  datagrams in a single call over a connected stream().
- test_udp_receive_after_connect (p2): datagrams from other peers
  queued before connecting are filtered out once connected.

* Give it one last poll before finishing up

* Unify the p2 & p3 socket implementations

The shared socket code (crates/wasi/src/sockets/*) was modeled after
the p2 interface, with p3 bindings papering over the differences, and
some functionality duplicated between p2/* and p3/*. This has already
caused bugs in the past (bytecodealliance#13631).

Since the p3 interface is strictly a superset of p2, invert that
relationship: the shared code becomes the canonical (p3-shaped)
implementation, and p3's bindings are now a thin wrapper around it.
All p2-only behavior & state moves into the p2 bindings layer instead
(artificial restrictions like disallowing implicit binds, and the
start/finish async bookkeeping).

Other notable changes:

- Each socket now stores its own copy of the WasiCtx's
  socket_addr_check at creation time, so all permission checks live in
  the shared socket code instead of being split across p2/p3. The p2
  Network resource is now just an unforgeable capability token.
- Removed the Bound state; whether a socket is bound is now determined
  lazily via getsockname/local_addr instead of tracked explicitly. This
  lets UdpSocket::send return a future that runs to completion
  independently, without needing to rendezvous back with the socket to
  update its state.
- Updated SocketAddrUse: added TcpListen, TcpAccept, UdpReceive;
  replaced UdpConnect with UdpSend/UdpReceive checks, since connecting
  a UDP socket is just a local operation that sets the default remote
  address and does no I/O of its own. connect() now succeeds as long
  as either send or receive is permitted for the address.
- Tcp/UdpSocket::connect now also check the implicit bind the OS
  performs when connecting an unbound socket, matching the check
  already done for explicit binds.

Added test coverage for previously-untested behavior:

- test_udp_disconnect_local_address (p2 & p3): disconnecting a UDP
  socket keeps it bound.
- test_udp_send_receive_multiple (p2): bulk send/receive of multiple
  datagrams in a single call over a connected stream().
- test_udp_receive_after_connect (p2): datagrams from other peers
  queued before connecting are filtered out once connected.

* Give it one last poll before finishing up