Road to stability of communications module

Done when:

• tests are in place to test the Kademlia code base
  *

Node Discovery should not rely on external sources to learn that given node disconnected from the network. Disconnect messages seems as an artifical abstraction that does not bring any value, neither were it is defined (NodeDiscovery) nor where it is being used (RChain protocol)

More details to be provided!

Signature change from

```
trait TransportLayer[F[_]] {
def roundTrip(peer: PeerNode, msg: Protocol, timeout: FiniteDuration): F[CommErr[Protocol]]
```

to

```
trait TransportLayer[F[_], P] {
def roundTrip(peer: PeerNode, msg: P, timeout: FiniteDuration): F[CommErr[P]]
```

This improves the readability of the code. Low priority.

What needs to be done:

• Investigate what is going on
• Determine how we can remove old nodes from the list.
• test the functionality.

This ticket is based on some discussion made in https://rchain.atlassian.net/wiki/spaces/CORE/pages/500367432/Communications+Module+-+current+state+and+challenges - please read it through before reading rest of this ticket description.

Currently NodeDiscovery is toupled with Rchain protocol which. RChain adds elements to table defined in NodeDiscovery (via addNode) and NodeDiscovery adds and removes those elements according to its own internal algorithms.

This leads to following errors:
1. nodes can send messages to each other even if they did NOT exchanged messages according to RCHain Protocol handshake
2. Node Discovery (Kademlia) will add nodes to its own tabel of peers without going through the RCHain Protocol handshake (will bypass)

The main root of evil here is the fact that NodeDiscovery *shares* same table of peers with RChain Protocol.

Right now when RChain Protocol:

1. can be called from the out side world via `connectToBootstrap` (goes through `connect` procedure for given bootstrap
2. asks periodically `findMorePeers` from Node Discovery (goes through `connect` procedure for each node returned

The way `connect` works is described in `ConnectSpec.scala`. In essence it sends message ProtocolHandshake and once received ProtocolhandshakeResponse it adds the given node to kademlia peer table. On the other side, upon receiving ProtocolHandshake message, ProtocolHandshakeResponse is being send back, and incoming node is added to Kademlia peer table.

Node Discovery (kademlia) abstracts concept of node attaching itself to existing P2P network and continuously learning about new nodes. The way that Kademlia works right now is following: it waits for outside calls like `addNode` and `findMorePeers` and triggers communication with the outside world if needed (sending Loopkup and Ping messages)

Node Discovery should be totally independent protocol, with only single method AddMe available as an entry point (sent once to connect given node to P2P network). Once that method is sent, NodeDiscovery should continuously explor the P2P trying to learn about neighbour peers and at the same time exposing single method listPeers. That method should allow listing all nodes that Node Discovery learned while runnings. Node Discovery should be totally abstracted away from anything build on top of it (like RChain protocol).
RChain protocol should hold list of its own peers (not tight to kademlia list of peers) and use Node Discovery to learn about new nodes in the network.

What should be done described in subtasks of this issue.