Remove Node.js 0.6 from Travis CI build.

Closes #75.
Update `t/compare.js` to ignore comments.

About to move away from the counted directive body to a sandwiched
directive body, using a universal closing tag. I'm anticipating the use
of jQuery plugins that manipulate the DOM by the innocents. Counted
directive bodies are exceedingly fragile. There would have to be a
difficult to describe rule about how any DOM rewriting by a jQuery
plugin would need to take place in a `div` in order to preserve the
directive body count.

The next commit will replace the directive count with a closing tag
which will be a single character, like a hyphen or a question mark,
indicating the end of the directive body. There will still be some
counting involved to find the closing body, maintaining a stack of any
directive bodies that are children. A closing comment based on the
opening would be easier to find, but I still want to maintain at least
the pretense of concern for the aesthetics of the serialized HTML.

Recall that I want my template language to be independent, ignorant of
the structure of the document. Attempting to latch onto the DOM of the
document is far more fragile than these comment markers in the face of
jQuery plugins and DOM rewriting, unless you want to impose a careful
accounting of element and element ids upon the user. That is more
objecty than it is templatey and Stencil is templatey.

Extraneous divs and spans are as unsightly as these comments. Moreover,
they are visible to CSS selectors and jQuery selectors, so they make
their presence felt no only in the serialized HTML, but all throughout
the code.

There is a path to take where you embrace this imposition, but we want
the behavior of a serialization-based template language; we want the
template language melt away, without leaving it's casting sprues all
over the document.

It was a slow process to decide to add a closing comment. I wanted to
avoid the arguments around the obvious complaint that Stencil will
litter the HTML. The closing comment makes it obvious that we're
creating an out-of-band element, so it makes it easier for a bothered
person to form the knee-jerk argument; you're using comments as elements
and that's wrong.

Here's a slice of counter argument.

The sacrifice to the serialized DOM (the HTML) is the price we pay to
get a micro-JS templating library that generates on the server and
regenerates on the browser using the same template. It is how we get
template behavior instead of object binding behavior.

Injecting comments is unsightly in the serialized HTML, but the
alternative, injecting divs and spans can be just as unsightly, and then
exposes structural details that serve the template language to every
aspect of the application.

Few of the existing frameworks emit HTML that is pristine, as if you
were to write it by hand, and once it gets into the browser and gets
scrambled by jQuery and the like, you need DOM inspector to know what's
really going on.

As far as adding extra weight to serialized HTML, it ought to compress
as well if you're serving your HTML gzipped, and the alternative of
extra divs and spans are as hefty.
Remove comments from XML fixtures.

The `compare` function in `t/compare.js` no longer accounts for
comments, so I've removed comments from the XML fixtures. Now `compare`
and the XML fixtures can be used to assert that the sandwiched directive
bodies maintain the functionality of the counted directive bodies.
Delete unused constants.

Deleting the the unused contants for the Stencil namespace and the XML
namespace namespace.

File                             Raw         Min         Zip     Min/Zip
redux.js                 28740/28.07  9361/09.14  7348/07.18  3582/03.50
Tidy tests.

Format tests constistantly and strip end of line spaces.
Tidy end of lines.

Strip spaces from the end of lines.
Implement out-of-band element.

Simplify the directive body marker logic by implementing a start and an
end marker that sandwiches a directive creating an out-of-band element
that does not effect CSS or jQuery selectors, that can account for DOM
rewriting by jQuery libraries.

The `vivify` function now takes note of both the beginning comment and
the ending comment, so that DOM manipulation is implemented as iteration
along siblings, looking for the end element using object comparison.
Developers can add new elements to the directive body and the directive
body can still be identified by the start and end markers.

I am not going to implement `recount` so this closes #74 as invalid.

I've been able to serialize this minimal implementation of tags for a
while now and I don't seen any issues with tag serialization going
forward, so this closes #54 also.

File                             Raw         Min         Zip     Min/Zip
redux.js                 23931/23.37  7592/07.41  6395/06.25  2988/02.92
Merge branch `tag` into `redux`.
Merge branch `redux` into `master`.