transports: Improves the robustness and success rate of connection dialing

[lexnv]

This PR improves the robustness and success rate of connection dialing by grouping peer negotiation (multistream-select) into the "open" (socket-to-socket connectivity) stages of the TCP and Websocket transports.
This avoids premature cancellation of potentially successful dials.

The litep2p establishes connection in two sequential stages:

• Step 1: socket to socket connection (raw TCP connection)
• Step 2: Peer negotiation (multistream-select protocol)

Previously, the transport manager would cancel all pending dials immediately after the first successful completion of Step 1.

Timeline:

• T0: Transport Manager dials peer on TCP Address A and Websocket Address B
• T1: Address A established raw socket connection (Step 1). The Transport Manager cancels immediately the dial to Address B
• T2: Address A proceeds to the peer negotiation (Step 2).
• T3: Negotiation on address A fails

Because at T1 the manager cancels all other attempts, the dialing is reported as failed without trying to dial more than one address.

To improve the robustness of the dialing process, Step 2 is merged with Step 1.

Implementation Details

Any installed protocol (TCP / Websocket) must comply to the following interface:

litep2p/src/transport/mod.rs

Lines 192 to 219 in f1b4e0b

	pub(crate) trait Transport: Stream + Unpin + Send {
	/// Dial `address` and negotiate connection.
	fn dial(&mut self, connection_id: ConnectionId, address: Multiaddr) -> crate::Result<()>;
	/// Accept negotiated connection.
	fn accept(&mut self, connection_id: ConnectionId) -> crate::Result<()>;
	/// Accept pending connection.
	fn accept_pending(&mut self, connection_id: ConnectionId) -> crate::Result<()>;
	/// Reject pending connection.
	fn reject_pending(&mut self, connection_id: ConnectionId) -> crate::Result<()>;
	/// Reject negotiated connection.
	fn reject(&mut self, connection_id: ConnectionId) -> crate::Result<()>;
	/// Attempt to open connection to remote peer over one or more addresses.
	fn open(&mut self, connection_id: ConnectionId, addresses: Vec<Multiaddr>)
	-> crate::Result<()>;
	/// Negotiate opened connection.
	fn negotiate(&mut self, connection_id: ConnectionId) -> crate::Result<()>;
	/// Cancel opening connections.
	///
	/// This is a no-op for connections that have already succeeded/canceled.
	fn cancel(&mut self, connection_id: ConnectionId);
	}

TCP/Websocket protocols now implement:

• fn open integrates step 1 and step 2 (with peer negotiation)
• TCPAddress A is reported to the manager only after the negotiation phase
• fn negotiate forwards the already negotiated connection to the manager immediately (no-op since it was already handled)
• WebSocket Address B is correctly dropped since we have a connection on the TCP socket

Closes: #232

[dmitry-markin]

Nicely done here! 🚀

[dmitry-markin]

May be we can delete negotiate fn from the trait completely, highlighting the fact that negotiation should happen as part of open()?

And likely rename self.opened_raw -> self.opened.