read output from stdout and stderr while cmd is running

This updates the cmd to begin reading from stdout and stderr as
soon as the cmd has started running.  This is accomplished by
starting a thread that reads `READ_SIZE` bytes from the io as long
as the cmd is running.  Data is read using `read_nonblock` and new
data is detected using `IO.select`.

As before, calling `wait` if the cmd was started asynchronously
is highly recommended (this either waits for the cmd to finish or
times out).  Either way, this ensures the read output thread is
exited and the exitstatus captured.  This is handled automatically
if the cmd is started synchronously using `run`.

The goal here is to prevent "deadlock" scenarios where a cmd can't
finish b/c it has filled up one of the output streams.  It also
enables output "streaming" as output will now be available for
inspecting as soon as it is written.

I've added some deadlock tests where I test both a `cat` cmd on both
a small and big file.  The big file is larger than 64k (the default
buffer size of stdout).  Both execute the cmd just fine without
deadlocking and timing out on the `.wait(1)`.  This test fails without
these changes.

To accomplish this, I also remodeled the command's "run data" as a
"child process" object.  This is a more appropriate name for the
data and behavior this is encapsulating.  This allows the same
access to the child process' data and allows us to abstract child
process handling behavior in this object.

Finally, this switches to _not_ stripping any read output.  This is
necessary b/c we are now streaming output but also good b/c we want
to preserve the output exactly as the cmd produced it.