Network tweaks

`NetAddress` is now just `Address`, and it's a string. Most of the standard library network functions operate on strings, and this also means we don't have to perform ugly int -> string conversion all over the place.

RPC internals have been tweaked a bit; functionality is not affected. I also implemented a proper "ping-pong" RPC, so you can be confident that an address for which `Ping()` returns true is a potential peer.

Next priority, network-wise, is properly handling RPC errors. There will probably be a lot of logic changes bundled with that, because the ability to check for errors gives you the option to resend, try another peer, etc. However, it's important to keep in mind that error messages can be falsified. So the code should not branch on errors in a way that is attackable.

Finally, I was thinking about it the other night and I'm pretty sure I could make RPC functions return a value instead of modifying a pointer. e.g.:
```go
func RPCfoo(arg string, response *string) error {
    *response = "foo"
    return nil
}
// becomes
func RPCfoo(arg string) (string, error) {
    return "foo", nil
}
```
If you think this is cleaner/clearer, I could likely include it in this PR.
kind of a pain to have these, but we need some way to prevent attackers from overwhelming us with large messages. So it's best to tailor each `Read` so that it clamps the acceptable message length as much as possible.

A simpler approach would be to set a global length maximum, e.g. 1 << 24, for all messages. Then as soon as someone tries to send something longer, you blacklist them. But I believe this is still attackable, because you could send messages of length 1 << 23.

Defending against DoS attacks is going to be tough. As it stands, we're very attackable. Just off the top of my head, another easy attack would be to just open tons of connections to a host and then leave them hanging, forcing a 5 second timeout on every one.