Move tests around in test directory.

Moved `t/step/step.t` to `t/cadence`.

Closes #15.
Merge branch `shuffle-tests` into `master`.
Cadence now builds a function.

Cadence now builds a function that you invoke. This function will accept
a callback with a Node.js error, result signature. If an exception is
raised and not handled within the cadence, the callback is called with
the unhandled exception. If no error occurs, the callback is called with
the results of the final cadence function.

If no callback is given, any return value is ignored. If an exception is
raised and not handled within the cadence, the exception will be thrown.

At this point, only the exception handling is working. I've not get
gotten the return values to work.

Closes #13.
Closes #12.
Merge branch `functional` into `master`.
Error-free default exception handling.

The default callback for the master cadence was not checking to see if
the error was null before throwing it. I'd assumed that it would only
be called if there is an error, but it is always called when the master
cadence successfully completes.

Closes #17.
Merge branch `unexceptional` into `master`.
`README.md` snippit now runs.

The `README.md` snippet that introduces Cadence will not run if you cut
and paste it into a file and feed it to Node.js.

Closes #9.
Merge branch `readme` into `master`.
Define wrappers.

Tests for the use of a wrapper by a caller to lay hands on a step before
it is evaluated. The caller can wrap the function and the wrapper
function will be called in lieu of the step function, but using the
parameters of the step function to infer context names.

Closes #3.
Merge branch `wrap` into `master`.
Parallel sub-cadences.

When you create cadence within a cadence, that cadence will run in
parallel to any other cadences declared in the cadence. All parallel
cadences will complete before the next step in the cadence is invoked.

Not at all difficult, really, but I got confused for a time and was
looking at inspecting the stack using exception stack traces and
`argument.callee.caller`. Eventually I realized I was way off track. I
was very happy to find my way back to the code you see here. This is a
note to self, because such bouts of confusion are worth remembering.

Moving through the steps is now done using an index, instead of shift,
so well have the cadence in tact for when we implement branching.

Going to begin tracking sizes, because we're almost complete, and we're
nowhere near 2k. This can be a MicroJS library.

    File                             Raw         Min         Zip     Min/Zip
    index.js                  7478/07.30  2838/02.77  2385/02.33  1241/01.21

Closes #19.
Closes #4.
Merge branch `stacked` into `master`.
Add sizes to build.

Add sizes utility from Timezone. Display minified size during tests so
that they show up in Travis CI output.

Closes #22.
Closes #21.
Merge branch `build` into `master`.
Added Travis CI chicklet to `README.md`.

Closes #11.
Merge branch `build` into `master`.
Notes on usage as recursive directory delete.

Notes on usage expressed as a recursive directory delete. Two examples
of delete tree, one serial, one parallel.
Implement branching.

Unfortuately, naming a function in an argument list creates an
anonymous function that is not hoisted. In order to get a handle to the
function in the closing scope, I must create a variable with var and
assign an anonymouse function to the variable within the argument list.

It is not as pretty as using a named function, expecting it to be
hoisted.

It's occurred to me while writing this that I could use named functions
by adding them to the context, then requesting them by name.

I'm going to leave the current implementation in place, because while
looking into why things didn't work as expected, I learned that there
are lots of legacy issues with [named function
expressions](http://kangax.github.com/nfe/). They won't effect Node.js,
and going forward, as people `"use strict"`, there will be cases of
recursion where there's no way around using named function expressions.

    File                             Raw         Min         Zip     Min/Zip
    index.js                  7895/07.71  3047/02.98  2486/02.43  1323/01.29

Closes #2.
Merge branch `loop` into `master`.
Use function names to identify branches.

Now when a named function is used as a step, the named function is added
to the context of the cadence. It can be requested by name through step
function parameters like any other context object.

Instead of receiving the step function itself, however, the user
receives a wrapper that will record the arguments passed to the step
function. When the current step function has completed, the wrapper will
move the cadence to the wrapped step function. The step function will be
invoked with the recorded parameters.

If the `cadence` function is passed the wrapper as the first argument,
it will create a callback that will move the cadence to wrapped step
function if it is invoked. The wrapped step function will be used to
infer the context names of results given to the callbacks.

We changed the behavior of `cadence` when it is invoked with a direct
reference to a step function as it's first argument to match that of
being invoked with a wrapped named step function as the first argument.
Calling `cadence` with a direct reference to a step function will return
a callback that will move the cadence to the referenced function if it
is invoked. The wrapped step function will be used to infer the context
names of results given to the callbacks.

Closes #24.