Starts stalling under load

Using this benchmark:

```
import (
"net"
"testing"

"github.com/anacrolix/utp"
)

func getTCPConnectionPair() (net.Conn, net.Conn, error) {
lst, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return nil, nil, err
}

var conn0 net.Conn
var err0 error
done := make(chan struct{})
go func() {
conn0, err0 = lst.Accept()
close(done)
}()

conn1, err := net.Dial("tcp", lst.Addr().String())
if err != nil {
return nil, nil, err
}

<-done
if err0 != nil {
return nil, nil, err0
}
return conn0, conn1, nil
}

func getUTPConnectionPair() (net.Conn, net.Conn, error) {
lst, err := utp.NewSocket("udp", "127.0.0.1:0")
if err != nil {
return nil, nil, err
}

var conn0 net.Conn
var err0 error
done := make(chan struct{})
go func() {
conn0, err0 = lst.Accept()
close(done)
}()

conn1, err := utp.Dial(lst.Addr().String())
if err != nil {
return nil, nil, err
}

<-done
if err0 != nil {
return nil, nil, err0
}

return conn0, conn1, nil
}

func benchConnPair(b *testing.B, c0, c1 net.Conn) {
b.ReportAllocs()
b.SetBytes(128 << 10)
b.ResetTimer()

request := make([]byte, 52)
response := make([]byte, (128<<10)+8)

pair := []net.Conn{c0, c1}
for i := 0; i < b.N; i++ {
if i%2 == 0 {
pair[0] = c0
pair[1] = c1
} else {
pair[0] = c1
pair[1] = c0
}

if _, err := pair[0].Write(request); err != nil {
b.Fatal(err)
}

if _, err := pair[1].Read(request[:8]); err != nil {
b.Fatal(err)
}
if _, err := pair[1].Read(request[8:]); err != nil {
b.Fatal(err)
}
if _, err := pair[1].Write(response); err != nil {
b.Fatal(err)
}
if _, err := pair[0].Read(response[:8]); err != nil {
b.Fatal(err)
}
if _, err := pair[0].Read(response[8:]); err != nil {
b.Fatal(err)
}
}
}

func BenchmarkTCP(b *testing.B) {
conn0, conn1, err := getTCPConnectionPair()
if err != nil {
b.Fatal(err)
}

defer conn0.Close()
defer conn1.Close()

benchConnPair(b, conn0, conn1)
}

func BenchmarkUTP(b *testing.B) {
conn0, conn1, err := getUTPConnectionPair()
if err != nil {
b.Fatal(err)
}

defer conn0.Close()
defer conn1.Close()

benchConnPair(b, conn0, conn1)
}

```

I get the following:

```
PASS
BenchmarkTCP-4 5000 263246 ns/op 497.91 MB/s 27 B/op 0 allocs/op
BenchmarkUTP-4 2016/05/26 23:21:51 error resending packet: write udp [::]:56345->127.0.0.1:56344: use of closed network connection
2016/05/26 23:21:51 error resending packet: write udp [::]:56345->127.0.0.1:56344: use of closed network connection
2016/05/26 23:21:51 error resending packet: write udp [::]:56345->127.0.0.1:56344: use of closed network connection
100 134251556 ns/op 0.98 MB/s 1195857 B/op 4016 allocs/op
```

If you tweak the numbers a bit, you might get it to 0.2MB/s

I did manage to get it to a point where it just mostly never completes and fails with "connection closed", but that was using syncthings protocol wrappers which do async read/writes. In cases where it did complete it was around 0.3MB/s