This allows one to easily append multiple elements to the end at
once.

When handling files we do not want to grow too fast or too slow since
its a) wasteful or b) slow.

The restore result was not checked before

This construct enters into a deadlock if
1) the writer is waiting because the queue is full
2) the reader is waiting on the writer to quit

The reason is that this status is not communicated through the queue
but with a separate variable.

This commit makes it so the status is communicated only through the
queue itself.  Special note has to be taken in the case of a timeout
in the reader (res == fd->Timeout) since normally this branch does not
look at the queue at all.

Because of this we needed to add a function the the channel that
actively checks whether the other side is still alive.

utime_t (defined in bc_types.h) is needed to use this header.

This also fixes an issue that occurs if mmap/mremap fails.  In that
case buffer should be reset to nullptr, so that the destructor does
not try to unmap it a second time.

The test did not support each subtest getting called on its own (since
they shared state).  To fix this each test now gets its own file, as
well as each test setting up the file how they need it to be.

we use ftruncate if posix_fallocate does not work

It turns out that posix_fallocate can become very slow on glibc if you
the filesystem does not really support it since the fallback is just
writing a bunch of zeroes into the file.   This is not what we want so
we only use ftruncate for now.

We first try to extend the first mapping instead of doing the whole
unmark + mark step.