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.
Shouldn't be that tough. Doesn't each connection get handled in a separate thread? A standard computer should be able to manage hundreds to thousands of simultaneous connections iirc (though we should test it).

It's my understanding that if someone's got the resources to send you a single message of length 2^24, they've also got the resources to send you two messages of length 2^23 or 4 messages of length 2^22. My very ameture understanding of DoS boils things down to 2 attack vectors:

1. Attacker has more bandwidth then you, and consumes all of your bandwidth. Honest users can't get through the torrent.

2. Attacker is making computationally intense calls, and is spinning your computer cycles faster than you can keep up with requests. Making connections and then hanging should be managable just by putting each connection in a separate go thread b/c they don't actually put stress on the cpu.

The wikipedia page seems pretty comprehensive: http://en.wikipedia.org/wiki/Denial-of-service_attack