Implement new # and > calling convention

Both {{#foo}} and {{> foo}} are handled as follows:

- foo may be a template or a function returning a template
- if there are only keyword arguments, they are used to create a data context object (e.g. `x=1 y=2` becomes `{x:1, y:2}`)
- if there are any positional arguments, the arguments are treated as a nested helper call, meaning that the first one will be called on the rest (including keyword arguments) if it is a function

Rendering-wise, the template should only be re-rendered if foo is a function and it is invalidated to return a different value (though the "isolate" that would compare the new value to the old is not on this branch at the moment).

This change also makes the built-in block helpers (#if, #each, etc.) be functions (render macros) instead of components (though #each is still implemented with a component).  This avoids data context issues with #if and #unless (the new calling convention isn't really designed to support making something like #if).  It also should make generated code cleaner to call `UI.If` instead of including it as a component.
remove duplicate test
Fix calling convention with only keyword args
Merge branch 'shark' into shark-newargs
"atoms" example

Demonstrates "components" using the new convention where keyword args with no positional args become the data context.
Update tests of compiler output

Make a slight change to codegen that shouldn't affect behavior
More spacebars-compiler tests (errors)
Merge shark, including shark-isolate-helpers work
Fix "atoms" title tag
Merge remote-tracking branch 'origin/shark' into shark-newargs

Conflicts:
	packages/spacebars-compiler/compile_tests.js
	packages/spacebars-compiler/spacebars-compiler.js
Fix bug in newargs; fix some tests
Remove stray console.log
whitespace
Move re-render's isolateValue to UI; fix bugs

* Use isolateValue around `foo` in `{{> foo}}` as well as `{{#foo}}` (i.e. whether or not there's a content block)
* Make UI.With always embox its argument; this is achieved by moving embox/isolateValue from Spacebars into UI.  As a side effected, all reactive closures now use isolateValue, so we avoid re-rendering in a few more cases.
* Avoid calling data argument of `{{#with someHelper}}` twice ever instead of once ever (when helper isn't invalidated)
Add an XXX for failing test
Fix broken newargs semantics

All tests pass (except one which is a todo on shark).

If `{{> foo bar}}` is to desugar into `{{#with bar}}{{> foo}}{{/with}}`, there needs to be an explicit block in the generated code in which `self.lookup("foo")` binds the correct data context (`bar`).  So we now generate a UI.With rather than trying to call it from Spacebars.include.  This simplifies Spacebars.include, which is nice.

Define `lookupTemplate` because `self.lookup(.., {template: true})` pretty-prints bigly.
Fix data context and .. in {{> content}}

according to today's proposal (i.e. it's as if {{> content}} were invoked at the invocation site of the template that uses {{> content}}, as far as scopes are concerned).

Messy implementation with not enough comments.  But there's a test.
Merge branch 'shark' into shark-newargs
Simplify account-ui-viewer due to new template argument paradigm
On {{> foo}}, look for template before global helpers.

Motivated by our safe-guard to print an error when
using the old style {{loginButtons}}. And it seems
just as correct.