Refactor colored writing into WriteLine() function

This serves two purposes. It protects with a Mutex where it was missing
before, and makes it so that there is only one place to change code for
the line writing, which will be a later pull request.
Move mutex onto OutletFactory

It's bad form for the mutex to live in the global namespace when it
doesn't need to.
Simplify procName calculation
Use defer to mark goroutine completed

Also, move the wg.Add() next to the point where it matters.
Use defer to unlock mutex

This is safer in general, in case a function exits for any reason,
including due to a panic (which may be recovered later).
Refactor interrupt monitoring and shutdown

This makes it so that the same goroutine responsible for starting
processes shuts them down. This is a stepping stone to a larger refactor
whose goal is to eliminate race conditions.
Refactor ShutdownProcess to smaller platform-specific part
Refactor process shutdown

This is a large change which makes startProcess() responsible for
shutting its own process down, rather than having a global map.

This makes it much easier to reason about who owns what and get the
synchronization right.

The main immediate bugfix is that now we only attempt to send SIGKILL to
processes which haven't yet shut down, making it clearer which processes
are responsible for a delayed shutdown.

It introduces a `teardown` channel which is closed to signal to all
process-monitoring goroutines that they should clean up.

In addition, the platform-specific code has been thinned. Some of the
platform logic moved into the process-monitoring code because it needed
to for now after the introduction of the <-finished barrier.
Implement teardownNow with Kill on 2nd CTRL-C
Move 'shutting down' msg to before close(teardown)
Move envAsArray from Process onto Env
Eliminate p.Running and cross-platform

Now that the process which starts things is responsible for killing
them, it's no longer possible for the *Process to be nil, so the check
is unnecessary and there is no platform difference, so it's moved to
process.go.
Refactor ShellInvocationCommand

This is done because I want to make the *exec.Command shim narrower so
that we can transition to another method for reading Stdout/Stderr to
fix the newline bug described in #16.
Factor out PlatformSpecificInit()
Make Process.Start the same across platforms
Don't set p.Root in NewProcess

It's being eliminated by embedding the *Cmd in the Process.
Embed *exec.Cmd in Process struct

Motivation: Trying to slim the Process wrapper as much as possible to
make later transformations easier.
Eliminate unused imports from windows.go
Eliminate Pid() function
Add error handling to Signal()