5.4.0 release

The entire document is now evaluated as cljs, not just the contents of
the <body>. The trick used was found in the excellent Domo JavaScript
library (http://domo-js.com). Thanks Jed Smith (http://jed.is), wherever
you are...

This commit also fixes #8, which was closed as "wontfix".

* In previous versions only the contents of the <body> tag were
  evaluated as ClojureScript, due to browser compatibility issues with
  manipulating the <html>, <head> and <body> elements at runtime. A
  solution has been found, however, which should work in all modern
  browsers (Chrome, FF, Safari, IE8+). The implementation used does not
  need to call `document.open()` or try to build the document by adding
  elements to an empty document. Instead, the special <html>, <head>,
  and <body> elements are instead replaced with the evaluated CLJS
  expression. This means that these elements are sort of like singletons
  in a way, because creating a <head> element automatically installs
  that new <head> element into the DOM, replacing the existing <head>
  immediately. (Same with <html> and <body>, of course.)

* The `head` and `body` vars in `#'tailrecursion.hoplon` namespace are
  now macros, not functions. The corresponding functions are `html-body`
  and `html-head` now.

  The `head` is a macro to provide backwards compatibility with previous
  versions of hoplon where the head was not being evaluated. In previous
  versions it was correct to use the <meta> tag inside the head
  expression, but there is a conflict with `#'cljs.core/meta` that
  required the user to use `html-meta` to create a <meta> element from
  CLJS. Now the `head` macro binds `meta` to `html-meta` for you so you
  can continue to use `meta` in the <head> expression as before. Outside
  of the <head> expression you must use `html-meta`, same as before.

  The `body` is a macro now to work around a strange situation with FF
  and Safari browsers: deeply nested expressions were causing a severe
  slowdown of the initial building of the DOM where it could take
  minutes to evaluate a single expression. These deeply nested
  expressions were a natural result of using CLJS as markup. The `body`
  macro now "flattens" its arguments, unrolling the tree and assigning
  each subexpression to an intermediate variable in a let binding. This
  was done by code-walking in the hoplon compiler in previous versions.
  The `body` macro is more general and less brittle.

* The `prerender` task now provides better warnings and error
  propagation from PhantomJS.