Include tags without descending into template.

It was my intent to allow  tag library authors to include resources with
`xmlns` directives on the `include` element.

Descending into the document and walking it using our existing template
logic causes these requires and includes to be evaluated. I thought the
implementation would simply grab the short stack created by this
descent, then start a descent into a tag primed with the `include`
element stack. However, the `include` element might require a dynamic
data source, which would generate a push end point. That one push end
point would push into any document that included the template.

One push end point updating multiple documents is depressing.

Instead, we gather up the tags. When we want to dive into a tag, we
start from the include element, skip all tags except for the one we want
to visit, and have the include and require directives play out as if
they were a part of the document.

The next step is to implement dive from `include`. With this commit I've
extracted the available tag names into a collection attached to the
template data structure.
Remove `depth`; old `layout`, `block` functions.

Tidy up the code by getting rid of the old `layout` and `block`
functions. The `get` function used by `block` is no longer used.

Also removed used `depth` variable.
Sort out use of `document` and `nodes`.

Removed the variable name `doc` where it was found. Instead I'm naming
my documents `document` and the contents of a document or the results of
a template `nodes`.

I removed `document` as a keyword from the default syntax highlighting
for JavaScript in Vim. This was why I was avoiding the variable name
`document`. The variable `doc` looks silly and does not reflect the
stature of that which it references.
Created descent data structure.

Wrapped the details of a descent into a document into a data structure.
Reduces the signature of our workhorse `xmlify` function.

In the stack in the `descent` structure, `evaluations` has been renamed
`assignments`. In the `stencil` structure, `evaluations` has been
renamed `dynamics`. The `createDescent` method helps to make the
creation of a descent less fiddly, more declarative.

Will still manipulate the `stack` directly. The `descent` gathers our
descent state, it does not encapsulate it.

Renamed the `wrap` function to `createElement`.

Brought in the `validator` function from Strata.

Closes #28.
Closes #27.
Descend into include through `include` element.

Descent into an include will also descend through the `include` document
element, as well as descending through the `tag` element. This will
apply any requires or includes made by the `include` or `tag` elements.
Tag library pull, evaluated attributes.

Implemented the tag library for a pull, but have not yet implemented
push. Descent into tags works both for imported tags and tags declared
by tag blocks.

Moved the construction of the `included` directive wrapped `tag`
declaration into the library `include` function. Tags are now ready to
go when they are encountered. The same logic that descents through the
`include` directive can be used to descent through a `tag` directive
that is a block child.

Implemented `parameter` which allows a library to inject its context
into the context of the caller when rendering a caller's block.

Implemented evaluated attributes. I'd included them in my tag library
example stencils, having forgotten that I'd forgotten to implement them.

Closes #53.
Closes #32.
Implement tag libraries.

Now able to import a simple tag library and have it participate in
pull-to-push dynamic regions. Our serialized stacks now include
references to any tags defined by include or block entry.

The descent object has been converted into a linked list of descents.
When we generate a context for an evaluation, we go up the list of
descents including all stacks for any descent matching the URL of the
current descent.

We're doing a better job of tracking dirty sections, inheriting
properties marked as dirty when we travel through a block or tag.

We've created two collections of assignments now, one for static
entries, one for dynamic entries. Our serialized descents will now only
contain a reference to a data structure.

We're assigning ids to elements in templates that define operations,
both user defined tags and Stencil directive elements. The id is a
combination of template id and document order. XML DOM has been patched
to fix a bug where it did not include the `documentElement` when
`Document.getElementsByTagName` was invoked; the `package.json`
references the release with this update.

    File                             Raw         Min         Zip     Min/Zip
    index.js                 34152/33.35 12484/12.19  8557/08.36  4491/04.39
Merge branch `tags` into `travis-ci`.