Fix two more bugs.

Unfortunately, two more subtle bugs to fix:

- If the encoded protobuf message is only three bytes long (or less),
  not only the whole protobuf will fit into headerBuf, but also the
  beginning of the next length varint. This will completely wreak
  havoc in the read process. (This bug never bit us in Prometheus
  because the protobuf messages were all long enough. But protobufs in
  general can be very small (0 bytes in fact). I added a test for
  that.)

- If the reader stops in the middle of a length varint, it will
  interpret the null byte that is already in headerBuf as the final
  byte of the varint, which again wreaks havoc. (This bug only shows
  up in Prometheus after
  https://github.com/prometheus/prometheus/commit/dfb9c2a072d5c1003e78c4921988c21bc76ab07a
  , and it is very rare... needs very unlucky fragmentation on the
  network.)

Solution to the first bug is to read byte-wise, which is slightly less
effective, but simplifies the code later, because we don't "overshoot"
anymore. Solution to the second bug is to only read the parts of
headerBuf that have been written to.
What I would like to see for the delimited support is a full suite of table-based tests with both real examples and regressions included in the tables.  If you'd be willing to populate these three tests with said data from here, I would appreciate it (as opposed to adding one regression test case as we have here):

```go
package ext

import (
	"bytes"
	"testing"

	"code.google.com/p/goprotobuf/proto"
	"github.com/matttproud/golang_protobuf_extensions/ext"
)

func TestWriteDelimited(t *testing.T) {
	for _, test := range []struct {
		msg    proto.Message
		stream []byte
		n      int
		err    error
	}{
	// Cases here.
	} {
		var buf bytes.Buffer
		if n, err := ext.WriteDelimited(&buf, test.msg); n != test.n || err != test.err {
			t.Fatalf("WriteDelimited(buf, %v) = %v, %v; want %v, %v", test.msg, n, err, test.n, test.err)
		}
		if out := buf.Bytes(); !bytes.Equal(out, test.stream) {
			t.Fatalf("WriteDelimited(buf, %v); buf = %v; want %v", test.msg, out, test.stream)
		}
	}
}

func TestReadDelimited(t *testing.T) {
	for _, test := range []struct {
		stream []byte
		msg    proto.Message
		n      int
		err    error
	}{
	// Cases here.
	} {
		msg := proto.Clone(test.msg)
		msg.Reset()
		if n, err := ext.ReadDelimited(bytes.NewBuffer(test.stream), msg); n != test.n || err != test.err {
			t.Fatalf("ReadDelimited(%v, msg) = %v, %v; want %v, %v", test.stream, n, err, test.n, test.err)
		}
		if !proto.Equal(msg, test.msg) {
			t.Fatalf("ReadDelimited(%v, msg); msg = %v; want %v", test.stream, msg, test.msg)
		}
	}
}

// TestEndToEndValid validates that valid messages can be passed through the
// encoding and decoding pipeline with fidelity.
func TestEndToEndValid(t *testing.T) {
	for _, test := range []struct {
		msgs []proto.Message
	}{
	// Cases here.
	} {
		var buf bytes.Buffer
		var written int
		for i, msg := range test.msgs {
			n, err := ext.WriteDelimited(&buf, msg)
			if err != nil {
				// Assumption: TestReadDelimited and TestWriteDelimited are sufficient
				//             and inputs for this test are explicitly exercised there.
				t.Fatalf("WriteDelimited(buf, %v[%d]) = ?, %v; wanted ?, nil", test.msgs, i, err)
			}
			written += n
		}
		var read int
		for i, msg := range test.msgs {
			out := proto.Clone(msg)
			out.Reset()
			n, _ := ext.ReadDelimited(&buf, out)
			// Decide to do EOF checking?
			read += n
			if !proto.Equal(out, msg) {
				t.Fatalf("out = %v; want %v[%d] = %v", out, test.msgs, i, msg)
			}
		}
		if read != written {
			t.Fatalf("%v read = %d; want %d", test.msgs, read, written)
		}
	}
}
```

What is nice about this is that the table definition format is concise and makes it stupendously easy to add additional cases to it as necessary.  The output messages are sufficiently informative to say, "Foo(X) got Y but expected Z", which we want for a pure system test as such.  You cool with that?  The prototype I wrote up above should be drop-in-placeable with nil effort and serve us well for the future.