simple BufferedWriter type

```go
func (w *BufferedWriter) Close() error

func (w *BufferedWriter) Flush() error

func (w *BufferedWriter) Write(p []byte) (int, error)
```

- BufferedWriter writes blocks when flushed or MaxBlockSize bytes
  accumulate.

- Add tests and benchmarks corresponding to Writer's.

- Rewrite existing tests to demonstrate buffering misalignment.
  bytes.Reader/.Buffer types have optimizations which help in io.Copy.

Closes #3
I think embedding bufio.Writer in BufferedWriter is a bad idea. Aside from allowing someone to change the value (replacing it with something that doesn't even produce a snappy stream) I actually think proxying the methods is good because it provides a well-known, discrete location to document the snappystream-specific meaning of each method (instead of cramming all package-specific docs into the type/field godoc). It also effectively pulls in the whole bufio.Writer API into the package, increasing the footprint (if not in godoc lines, in cognitive load). Really, the only methods that you need in the context of streaming compression are Write() and Flush(). The number of bytes currently buffered shouldn't matter to a user importing snappystream in their web server or client.

The API does mirror gzip.Writer. I don't have a reference saying why gzip is doing it the right way. I can only answer with anecdotes :(

I think it's largely idiom/convention. When I see a Writer I look for the Close method and when I see it I know that I should call it when I'm done. You could make a similar argument for Flush (if it's defined you probably will need to flush), but [Closer](http://godoc.org/io#Closer) is the standard idiom for such behavior in Go.

Someone may write a function `WriteFoo(io.WriteCloser)` that writes stuff to it's argument and closes it (asynchronously). It can be convenient is such cases when there is a process that must occur in order to "finish" writing. In fairness, that case could occur but is slightly artificial; functions like that seem more common with io.ReadCloser (net/http and a few other stdlib have example of that kind of function/method).

Finally, closing is a way to programmatically signal that there should be no further writes (they all fail with an error that lets you know you messed up).