[Peerstore] Pin/Unpin interface for peerstore

[aarshkshah1992]

Motivation

• The peerstore currently allows ANY caller to change the TTL of a peer. For eg: The Identify service changes the TTL of a peer to 10 minutes when a peer disconnects.
• However, this can be problematic as we might later want to attempt a reconnection to the same peer after the expiry and we will have no address for that peer at that point.
• Please see the "Address Management" section on this comment for a motivating example.

Solution

• The solution is to allow callers to express an interest in keeping the addresses for a peer around longer than mandated by the TTL via a Pin interface and then proactively undo the action via an Unpin interface. We should also account for buggy subsystems that forget to Unpin.
• See Pin/Unpin peer addresses go-libp2p-core#117 for a first stab at the implementation and the comment by @raulk on the PR to understand the subtleties involved in implementation of this issue.

Design Notes(to be refined)

• Subsystems holding onto a peer Pin() that peer, and Unpin() when they’re done.
• We refcount, and only peers with refcount = 0 are subject to expiry.
• We need to worry about badly-behaved / buggy subsystems.
• We should make pinning “best-effort”, i.e. the peerstore is not guaranteed to keep the peer pinned. Maybe subsystems can periodically ConfirmPin() to confirm that they still want a peer to stay pinned. We could prune peers that have not been confirmed in a while. Alternatively, pinning could maybe expose a context-like handle, indicating the pin is in effect. Peerstore then can close that pin to indicate it won't be honored unless the interested subsystem re-pins the item.
• On restart, we would garbage collect after a delay of, e.g. 10 min, to give the system time to warm up and restore any pins it actually wants.

Also, take a look at the Protect/Unprotect API in the ConnectionManager interface for inspiration.

[Stebalien]

I'm concerned that managing refcounts across services and crashes will get very tricky. I'd prefer to use named pins (similar to connection manager tags):

interface {
    // ttl is just a suggestion to make our lives easier.
    Pin(id peer.ID, service string, ttl time.Duration) error
    Unpin(id peer.ID, service string) error
    IsPinned(id peer.ID, service string) (bool, error)
    // Requires a reverse index, may be overkill but is definitely useful.
    ListPinned(service string) ([]peer.ID, error) // channel?
}

Note: if services need to associate values with peers, they should use the metadata interface. These values should be cleaned up when the peer is forgotten.

[aarshkshah1992]

Priority bump.

See libp2p/go-libp2p-kad-dht#520 (comment).