Block reader should fetch each block independently

Previously, we fetched the maximum size of a block (4096 bytes)
then read any blocks in that chunk until
we ran out of bytes.

With compression, one 4096 chunk can contain many blocks. If we
wanted a number of bytes exceeding the maximum block length,
and the number of compressed blocks held solely within the 4096
byte chunk didn't have enough data, then we'd attempt to
decompress the remainer of the 4096 chunk which
isn't fully contained in the 4096 chunk, causing errors
while decompressing (we weren't checking and reading more
data from the underlying file in this case).

Example:

event data of 13,000 bytes.

Blocks:

4096 bytes (1400 bytes compressed)
4096 bytes (1400 bytes compressed)
4096 bytes (1400 bytes compressed)
712 bytes (300 bytes compressed)

Total: 13,000 bytes (4500 bytes compressed)

Let's request 13,000 bytes of uncompressed data.

The previous algorithm was:

Fetch the maximum size of a block of compressed data (4096) bytes. In
this example, we'd fetch the first 2 blocks from the file, and part
of the 3rd block.

While we haven't decompressed the required 13,000 bytes, decompress
blocks from the raw data previously read from the file.

In this example, we'd successfully decompress the first two blocks
for 8192 bytes.  When attempting to decompress the third block,
we haven't yet fetched it all from the file, so the decompression
will be invalid.

This change ensures we always have read enough data from the file
to decompress the next block.