Implement pipeline scaffolding.

Proof was initially implemented to have `git` argument convention, where
`proof` is the primary executable and the first argument is a command to
`proof`. The ideal was to break up the functions of the `proof`
executable into smaller, UNIX-way programs that would generate and
consume streams of text. The programs would not be individual
executables, but commands implemented by a single `proof` executable.

Within the `proof` executable, I'd implemented a default pipeline as the
default operation when `proof` is invoked without a command. It would
pipe the output of `proof run` to `proof progress`. This pipeline could
also be invoked using the `piped` command.

With this commit, rather than have a single pipeline built into `proof`,
the `proof` executable will execute arbitrary extension programs. When
`proof` is invoked with a command it does not recognize it will search
the search `PATH` for an executable. Given the command `proof example`
Proof will look for an executable with the name `proof-example`.

An extension program can be written in any language, but I'd recommend
`bash`, because its a shell, so its easy to write pipelines.

The default pipeline is now implemented as an extension program named
`proof-default`. It is called if no command is specified, or else if
`proof default` is invoked.

Additionally, I've provided an executable `proof-getopts`, written in
bash, that implements GNU `getopts`, so that you can implement long
options on any target operating system. This is based on the project
[getopt](https://github.com/bigeasy/getopt/blob/master/getopt). That
project as been added as a submodule. The `Makefile` will make an
executable of it and copy it into the `bin` directory.

Closes #18.
Merge branch `scaffold` into `master`.
Extracting context, Step like asynchronous flow.

A test maintains a context. This is the context that is initialized
through the use of a harness. This has been passed in as the first
argument to the callback function. With CoffeeScript, we were able to
use destructuring assignment to get local variables out of the context
object. For JavaScript, we destructure assignment based on the function
parameter names.

We take advantage of the source code representation of the callback
function returned by `Function.toString` to extract and parse the
parameters. Based on the parameter names, we create an argument array
for the callback using the parameter names as keys into the context
object.

There are two special names.

The parameter names `_` and `callback` will receive a callback function
in case the test function wants to handle asynchronous callbacks itself,
without the use of the control-flow built into the Proof library.

A new method has been added to the test object, `store`. This will
generate a callback that will capture the output of a Node.js callback
with the canonical `(error, result)` signature. If there is an error,
the test will bail out.

Proof now provides asynchronous flow control without Streamline.js. The
flow control is tailored for Proof tests, which are brittle and short
lived. No elaborate efforts are made for error recovery in Proof tests,
so the only action taken on error is bail out. The one context would be
crowded after a while in a long running program, but it shouldn't be a
problem in short, specific Proof programs.

The indentation ought to be minimal. The flow control and harness setup
ought to make for short, succinct test programs.

Streamline.js and CoffeeScript are still supported. The application
developer must simply install Streamline.js or CoffeeScript and use
their executables for the shebang line. Streamline.js support is reduced
to a simple branch that detects `_` in the function signature.

I'm eager to see what problems arise from parsing the function
signatures. I'll have to walk this back if there are problems I can't
imagine. If I do have to walk it back, it would be simply to expose the
`context` object as a property of `Test`. That is actually the case now.
`context` is a property of `Test`, but I like the readability of the
parameter extraction.
Merge branch `extract` into `travis-ci`.