Descend using `rewrite`.

Descending the directive tree is now performed using a recursive call to
`rewrite`. There is no longer a descent of the directive tree internal
to the `rewrite` function.
Rename `template` test directory to `directives`.

I plan on creating a separate test directory to develop tests for tags.
Single pass convert, templates as fragments.

Now converting a template into a prototype page in a single pass. The
body of the template is moved into a fragment so that the root of the
template can contain multiple elements, which is necessary to compile
tag libraries where the `module` tag and the `tag` tags are flattened
into directive comments, all children of the same parent node.

Lost the ability to assert that assert that an if` directive is
correctly structured. May reintroduce later. May create a template
linter instead. Maybe leave it as is if it turns out to be a goof that
is easy to spot visually.

File                             Raw         Min         Zip     Min/Zip
redux.js                 25027/24.44  8491/08.29  6690/06.53  3151/03.08
Rewrite `t/sizes` and `t/test` for `/bin/sh`.

Rewrote `t/sizes` and `t/test` to run in old-timey `/bin/sh` without
arrays.
Minimal tag.

Include a tag from a tag library that contains a single tag that
contains HTML with no Stencil directives.

The directive handlers now accept a template. This is a page template, a
prototype page that defined the set of directives that currently being
rewritten. I now distinguish between the prototype page and the page
being generated. A directive now keeps a path that is the path to the
directive element in the template, so a handler can navigate that path
in the template if it needs to get a copy of the directive's body.

The directive handlers now accept a `rewrite` function that is a wrapper
defined by the main `rewrite` function that encloses the parameters that
must be passed to a subsequent `rewrite` that the handler function would
otherwise pass through and not change. This is to keep the function
signature from getting to unwieldy.

The compiler now gathers up a library property in the template that is a
map of tag names to tag directives. The `rewrite` function now passes a
library map and extends it with the library definitions included by an
"include" protocol namespace declaration.

In coming commits, I'm going to scan to calculate the length of a
directive body after calling rewrite, instead of assuming that the
length prototype directive body is the length of the rewritten directive
body. I've begun to implement the scanning with tags.

See #51.
Use object equality to test node identity.

I was using a special comment injected into the DOM prior to rewriting a
directive body to mark the end of a directive body. Directive body is
then calculated by searching for the special comment. The special
comment was thought to be necessary because of a memory of `isSameNode`.
The `isSameNode` function has been mercifully put to rest.

The program to an interface dogma leads developers to believe that they
have to extend their interface to include any possible implementation;
the dogmatic approach leads one to believe that the interface cannot
identify the object, so stark is the "separation of concerns."
Adjust directive comments for substitutions.

When an `if` or `each` directive contains a `value` directive as a
child, when the child is expanded there is a potential for the character
count of the parent directive's directive comment to change. Now I take
note of the current node that is the next sibling of the last element in
the directive body prior to rewriting the directive, then when the
directive is rewritten, I recount the nodes and characters.

I created the `insertBefore` and `removeChild` functions to patch
behavioral issues with the server side XML DOM library. This will remain
in place until the library is fixed.

I've created a `remark` which replaces a directive comment with a new
element and character count.

The element count now includes all nodes that are not character nodes so
that we know to include comment nodes, since comment nodes indicate
directive bodies. It was the case that a directive that did not yet have
a body -- specifically a `value` directive with no value -- would not be
counted in a parent directive body. It would contain only a comment, no
characters and no elements.

The new element count means that all the switch statements used to
determine the node type have been replaced by if/else statements. If it
is text, count characters, otherwise count "elements".

Renamed `visit` to `unvravel`.

See #51.
Rename `elements` to `nodes` in directive comment.
Delete dead branch.

Deleted a dead branch left over from the transition to recounting nodes
and characters in directive bodies.

File                             Raw         Min         Zip     Min/Zip
redux.js                 29422/28.73  9656/09.43  7482/07.31  3664/03.58
Use project `uglifyjs` in `t/sizes`.

The `t/sizes` script now uses the `uglifyjs` specific to the Stencil
project.
Use `findEnd` in tag logic.

Removed logic in the tag logic that duplicates `findEnd`.
Replace switch with if/else test of text node.

As noted in previous commit messages, in the directive comments, if it
is not a text node, it is counted as a node.
Run `comments` against `DocumentFragment`.

Instead of running the `comments` function against a directive body
after it has been inserted into the generated document, `comments` is
run against the document fragment returned by `scavenge`.

This creates a special case for the `each` directive. The prototype
marker maintains a set of item ids, indicating which items are present
in the document. The `each` directive handler deletes an id from this
set of item ids if the item is present when regenerating the `each`
directive. Now that we run `comments` against the fragment as it will be
inserted into the document, the `comments` function will see directive
comment for the specific item and add the id to the prototype item set,
when we'd just deleted it from the same set to indicate that it has
been seen in the new array.

I now delete from the item set after I've possibly added the id to the
item set by reconstituting a fragment using the `comments` function.
Swap items set.

To reduce the surprise of the side effect of `comments` adding the item
id to the item id set of the prototype I now assign the `items` property
of the prototype to the `items` local variable for use as a difference
set, then create a new empty set in the `items` property or the
prototype where the new set of items is built. When `comments` adds an
id to the item set of the prototype it now merely does what the `each`
directive handler has already done.

Closes #73.
Rename `comments` to `vivify`.
Merge branch `tag` into `redux`.
Merge branch `redux` into `master`.