refactor(peer) some _minor_ safety features

[btc]

This PR cleans up the peer package, making it a tiny bit safer to use.

• All peers are created using Peerstore. It is no longer simple to instantiate a naked peer. To create naked peers, use the mockpeer package.

(This refactor was performed because of work #416 and a promise I made a long time ago)

[jbenet]

I want to keep this as a Datastore. this abstraction doesnt hurt anything here. while it is not a TODO to make it persistent today, we have the option to.

[btc]

How about if we decide to go the persistence route, I'll nominate myself to do the dirty work?

(datastore impl about 50 lines of superfluous unmarshalling, type casting, and error checking)

[jbenet]

what unmarshaling?

[btc]

sorry. somehow visualized the cast as an unmarshal in my mind.

referring to these blocks of code

    k := u.Key(i).DsKey()
    val, err := p.peers.Get(k)
    switch err {

    // some other datastore error
    default:
        return nil, err

    // not found, construct it ourselves, add it to datastore, and return.
    case ds.ErrNotFound:

        // TODO(brian) kinda dangerous, no? If ID is invalid and doesn't
        // correspond to an actual valid peer ID, this peerstore will return an
        // instantiated peer value, allowing the error to propagate. It might
        // be better to nip this at the bud by returning nil and making the
        // client manually add a Peer. To keep the peerstore in control, this
        // can even be a peerstore method that performs cursory validation.
        //
        // Potential bad case: Suppose values arrive from untrusted providers
        // in the DHT.

        peer := &peer{id: i}
        if err := p.peers.Put(k, peer); err != nil {
            return nil, err
        }
        return peer, nil

    // no error, got it back fine
    case nil:
        peer, ok := val.(*peer)
        if !ok {
            return nil, errors.New("stored value was not a Peer")
        }
        return peer, nil
    }

k := peer.Key().DsKey()
    val, err := p.peers.Get(k)
    switch err {
    // some other datastore error
    default:
        return nil, err

    // not found? just add and return.
    case ds.ErrNotFound:
        err := p.peers.Put(k, peer)
        return peer, err

    // no error, already here.
    case nil:
        peer2, ok := val.(Peer)
        if !ok {
            return nil, errors.New("stored value was not a Peer")
        }

        if peer == peer2 {
            return peer, nil
        }

        // must do some merging.
        peer2.Update(peer)
        return peer2, nil
    }

[jbenet]

the merging is no longer there because we always create it here. sure, it's a bit of noise. can rebase to move the ds stuff to one commit so it can be reverted easily?

[btc]

can rebase to move the ds stuff to one commit?

That's how I roll 🐯 1e00779

[btc]

@jbenet addressed all comments RFCR

[jbenet]

LGTM