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`.
Merge branch `tag` into `travis-ci`.

Conflicts:
	redux.js