Y.Template and Y.Template.Micro - Generic template API and simple ERB/Underscore-style JavaScript templates

While working on a new widget recently, I found myself wanting a string-based templating solution that was more advanced than `Y.Lang.sub()` or `Y.substitute()`, but without the overhead of `Y.Handlebars`. I needed support for interpolation, if/else branching, and looping, but only for a few very small templates. Underscore-style templates (more familiar as ERB-style templates to Rubyists) seemed like exactly the right fit.

These commits add a new `Y.Template` class which provides a generic template engine API, and a `Y.Template.Micro` static class which provides a simple micro-templating engine. `Y.Template` can be used to compile, precompile, render, and revive precompiled templates using Handlebars or `Y.Template.Micro`.

### Y.Template

Using with `Y.Template.Micro` (the default template engine):

```js
YUI().use('template', function (Y) {
    var micro = new Y.Template(),
        html  = micro.render('<%= data.message %>', {message: 'hello!'});

    // ...
});
```

Using with Handlebars:

```js
YUI().use('template-base', 'handlebars', function (Y) {
    var handlebars = new Y.Template(Y.Handlebars),
        html       = handlebars.render('{{message}}', {message: 'hello!'});

    // ...
});
```

See the API docs for further details.

### Y.Template.Micro

Provides simple ERB/Underscore-style micro-templating. Can be used standalone or via `Y.Template`.

Within a template, `<% ... %>` is used to insert a block of JavaScript code, `<%= ... %>` evaluates and prints an expression as HTML-escaped output, and `<%== ... %>` evaluates and prints an expression as raw, unescaped output. Properties on the data object passed to a template function are made available within the template on the `data` variable.

Here's a simple template that renders a list:

```rhtml
<ul class="<%= data.classNames.list %>">
    <% Y.Array.each(data.items, function (item) { %>
        <li><%= item %></li>
    <% }); %>
</ul>
```

And here's the code to compile the template and render it (assume `listTemplate` is a string containing the template above):

```js
YUI().use('template-micro', function (Y) {
    var compiled = Y.Template.Micro.compile(listTemplate),
        html;

    // Render the compiled template to HTML.
    html = compiled({
        classNames: {list: 'yui3-list'},
        items     : ['one', 'two', 'three', 'four']
    });

    // And again, with a different set of data.
    html = compiled({
        classNames: {list: 'yui3-list'},
        items     : ['a', 'b', 'c', 'd']
    });
});
```

Precompilation is supported too, so Micro can be used to precompile templates at build time or on the server.

```js
// `precompile()` returns a string containing JavaScript code that will evaluate
// to a template function. It can be written to a file, served to a remote
// client, etc.
var source = Y.Template.Micro.precompile(listTemplate);
```

### Performance

`Y.Template.Micro` is significantly faster than both Underscore and Handlebars at both compiling and rendering templates. See http://jsperf.com/y-template-vs-others/6

### Running Locally

The built `template`, `handlebars`, and `yui` modules are intentionally not included in this pull request in order to keep the diffs clean. Before testing this change, you'll need to build them.

```bash
$ cd src/handlebars && shifter
$ cd src/template && shifter
$ cd src/yui && shifter
```