This reverts commit d5b2e09.

Refs webrtc-rs/sctp#28

Refs libp2p#2652

except destroy_substream which needs to be ported

reflects changes made in https://github.com/libp2p/rust-libp2p/pull/2724/files

by moving a reading future into Transport and polling it in a newly added `poll`.
https://github.com/libp2p/rust-libp2p/pull/2622/files#r876945521

also, remove dialer_connects_to_listener_ipv4/6 tests in favor of the smoke test.

to indicate that no more events will be coming from the stream

the logic was correct there

around RTCConfiguration

libp2p#2622 (comment)

also fix the smoke test (partially)

also, block_on writing to UDPMuxConn instead of spawning a thread.
refs libp2p#2622 (comment)

libp2p#2622 (comment)

turns out we can pass negotiated: true and id=1 on both ends.

* Dirty PoC for lock-less UdpMuxNewAddr

The general idea is this:

We use `flume` channels between the actual `UdpMuxNewAddr` instance
and a set of "handles", one per async-trait that we need to satisfy.

There is only one instance of `UdpMuxNewAddr`, meaning we can access
it via `&mut self` and drop all locks within it.

In the poll function, we can then decide, which events to prioritise
over others. Most importantly, all channels between handles and the
actual instance are "rendezvous channels", meaning, sending will block
until we actually read the item out of the channel. This allows us
to enforce backpressure from the poll function all the way to all
handles and into the task that is interacting with the handle.

* Remove locks from handle

* Replace `flume` with `futures::mpsc` channels

* Introduce `req_res_chan` module

* Move locking into `req_res_chan::Sender`

* Fill in more implementations

* Add TODO

* Implement send command handling, buffering items if we can't send them

* Remove tokio::spawn for handling waiting for closed sockets

* Remove futures::block_on in favor of local task set

* Fix clippy warnings

* Don't loop inside a loop

* Use match instead of `ready!`

* Fix webrtc version to rev prior to monorepo merge

* Never have more than one write future

This is to ensure backpressure. To not loose drop any packets, we
only read from the socket in case we are not currently writing a packet.

* Resolve TODO's for error handling

* Make `recv_buf` as short-lived as possible

* Replace AtomicBool with regular bool

* Remove unused import

* Simplify send_buffer handling

Instead of buffering multiple items, we only ever buffer one. To
work off this queue as quickly as possible, we put it at the top
of the loop which allows us to reduce some code duplication by
writing directly to the buffer in case we popped an item off the
queue and going back to the start of the loop which will trigger
a different code branch.

* Cargo fmt

…brtc-message-framing

With
mxinden/specs@865f4f2
the RESET no longer resets both write and read part of a stream, but only the
former.

port of libp2p#2813

This reverts commit e0fe0de.

…sport

ufrag is now multibase multihash

Refs https://github.com/paritytech/smoldot/pull/2759/files

credits to @thomaseizinger