Flatten evaluate, dynamic function.

Sorting out the workings of a pull-to-push function. Within the
`index.js` the beginnings of pull-to-push have already been implemented.
We'd extended the `require` directive to load a function that acted as a
callback when the module was a JSON provider.

That block of code was updated to look for the name `dynamic` attached
to the callback.

Flattened out evaluate. The special `callback` function passed to the
generated expression function has been removed; expressions will never
be asynchronous. Asynchronous comes when the expression returns a
function.
DOM based reference tracing.

Instead of tracing which JSON values are referenced using the proxy
based on property getter functions, we're running the templates a second
time and tracking what values are referenced. We can then do a compare
on the values to see if we insert the generated snippet or discard it.

Note that we're not comparing the generated DOM against the existing
DOM. That would create false positives when we're inserting HTML,
because the HTML parsing step might produce different output on the
server than in the browser. Plus, it would hurt to parse a big glob of
HTML only to discard it. Plus, comparing HTML generated DOM is slower
than a string compare of the source.

We are going to implement deferred parsing of HTML since it is obviously
going to be a performance hit. Any HTML source values that need to be
converted to DOM will be gathered into a structure. Only if the region
is dirty is the HTML source parsed and inserted into the DOM.

Nested regions are an unaddressed challenge. Serialization of templates
is now broken.

What's working is the push into the registered callback.
Merge branch `osx` into `pull-to-push`.
Pull to push for single each.

Implemented pull to push for a single template each. Evaluations are now
separated by a level of indirection. The stack indexes into an array of
evaluations. Keeps us from cloning JSON trees when we capture the stack.

In the stack, we no longer capture the context, but the series of
evaluations. We rebuild the context for each evaluation. This may be
slow, but for each directives, we can cache a calculated context.

Had a realization too, that we don't actually have to navigate the dome
to find the sources for our evaluation. We can cache them with the
values. The only thing we lose now from our proxied JSON tree is the
ability to know if an each directive touches a particular JSON tree.

Stencil is a template language, not a query language. We're not often
going to be performing joins of JSON trees within a template. It will
mostly be the case that an each directive will iterate over a particular
JSON tree. The dependency mechanism I was building with the JSON tree
proxies is of dubious value. For the most part, we'd have to walk the
entire tree anyway. Hard to imagine, at this point, if there was an
opportunity for performance improvements, and under what circumstances.
I don't feel like I'm losing anything other than complexity.
Remove JSON tree proxies.

Cleanup of the code now that pull to push is implemented without the
JSON tree proxies.

    File                             Raw         Min         Zip     Min/Zip
    index.js                 22637/22.11  8847/08.64  6229/06.08  3472/03.39
Merge branch `pull-to-push` into `travis-ci`.