Improve Attribute and Base performance

This improve the performance of the Attribute and Base components by making algorithmic changes as well as micro-optimizations along the "hot" code paths.

### Benchmarks

The follow are the results of running Base's benchmarks on this branch, and against 3.8.1. These test were run on a machine with the following configuration:

* Chrome 24
* MacBook Pro (15-inch, Early 2011)
* 2 GHz Intel Core i7
* OS X 10.8.2

#### Static ATTRS Aggregation + "Hot Path" Micro Opts + Single `addAttrs()` (HEAD)

```text
Base x 16,329 ops/sec ±2.31% (92 runs sampled)
MyBase x 16,214 ops/sec ±2.77% (93 runs sampled)
MyBase with 10 simple value attributes x 12,186 ops/sec ±2.55% (89 runs sampled)
MyBase with 20 varied attributes x 5,259 ops/sec ±3.30% (76 runs sampled)
BaseCore x 124,484 ops/sec ±1.99% (91 runs sampled)
MyBaseCore x 119,328 ops/sec ±1.58% (92 runs sampled)
MyBaseCore with 10 simple value attributes x 38,895 ops/sec ±2.30% (89 runs sampled)
MyBaseCore with 20 varied attributes x 6,896 ops/sec ±5.44% (63 runs sampled)
MyBaseCore with 20 varied attributes (using perf. best practices) x 17,184 ops/sec ±1.64% (95 runs sampled)
MyModelCore with 2 ad-hoc attrs x 70,288 ops/sec ±2.71% (87 runs sampled)
MyModel with 2 ad-hoc attrs x 13,406 ops/sec ±1.82% (94 runs sampled)
```

#### Static ATTRS Aggregation + "Hot Path" Micro Opts (21358a8)

```text
Base x 16,573 ops/sec ±2.44% (90 runs sampled)
MyBase x 16,177 ops/sec ±2.48% (86 runs sampled)
MyBase with 10 simple value attributes x 12,308 ops/sec ±1.60% (89 runs sampled)
MyBase with 20 varied attributes x 5,213 ops/sec ±3.27% (76 runs sampled)
BaseCore x 125,226 ops/sec ±1.75% (90 runs sampled)
MyBaseCore x 118,545 ops/sec ±1.44% (92 runs sampled)
MyBaseCore with 10 simple value attributes x 39,930 ops/sec ±2.02% (91 runs sampled)
MyBaseCore with 20 varied attributes x 7,265 ops/sec ±5.31% (61 runs sampled)
MyBaseCore with 20 varied attributes (using perf. best practices) x 18,531 ops/sec ±1.84% (90 runs sampled)
MyModelCore with 2 ad-hoc attrs x 72,395 ops/sec ±1.19% (88 runs sampled)
MyModel with 2 ad-hoc attrs x 14,345 ops/sec ±1.99% (91 runs sampled)
```

#### 3.8.1

```text
Base x 12,748 ops/sec ±2.00% (91 runs sampled)
MyBase x 13,070 ops/sec ±1.13% (93 runs sampled)
MyBase with 10 simple value attributes x 7,875 ops/sec ±2.82% (89 runs sampled)
MyBase with 20 varied attributes x 4,150 ops/sec ±2.44% (82 runs sampled)
BaseCore x 46,612 ops/sec ±1.69% (89 runs sampled)
MyBaseCore x 36,680 ops/sec ±2.65% (81 runs sampled)
MyBaseCore with 10 simple value attributes x 17,142 ops/sec ±1.23% (92 runs sampled)
MyBaseCore with 20 varied attributes x 5,526 ops/sec ±4.17% (74 runs sampled)
MyBaseCore with 20 varied attributes (using perf. best practices) x 9,146 ops/sec ±1.58% (91 runs sampled)
MyModelCore with 2 ad-hoc attrs x 30,979 ops/sec ±2.02% (88 runs sampled)
MyModel with 2 ad-hoc attrs x 10,648 ops/sec ±2.30% (92 runs sampled)
```

### Backwards Compatibility

These changes have been carefully designed to be backwards compatible in the 90%+ use cases. In fact we only know of one explicit area of backwards *incompatibility* as it's described below:

#### Inappropriate Touching of ATTRS

Many of these performance improvements are made possible by clever caching of the static ATTRS configs aggregation, this way work isn't needlessly done per-instance. Because of this we are evaluating the need for a static API(s) for mutating previously defined `ATTRS`, it would be something like:

```javascript
Y.Foo = Y.Base.create('mine', Y.Base, [], {}, {
    ATTRS: {
        bar: {value: 'BAR'}
    }
});

var foo1 = new Y.Foo();
Y.log(foo1.get('bar')); // => "BAR"

// Modifies Y.Foo.ATTRS.foo. This type of operation should be rare.
Y.Foo.modifyAttr('foo', {value: 'bar'});

var foo2 = new Y.Foo();
Y.log(foo2.get('bar')); // => "bar"
```

If you find yourself doing the above, that has some code smell to it. That said, if we find that it is very common for people to modify previously defined `ATTRS` *after* creating an instance, then we'll add the static `ATTRS` mutation methods.

#### Report Back-Compat Issues

**Please** report any backwards compatibility issues you run into when working with this code. While it has run the gauntlet of our unit tests, dropping this into real production app code is invaluable to changes like these.

### Next Steps: Event Performance

This pull request **only** tackles changes in `Y.Attribute` and `Y.Base`. The next phase of significant performance improvements to YUI will come through refactoring the event system. The following lists captures our high-level ideas and goals for event performance changes:

* Firing of events with no subscribers should be as close to a no-op as possible.
* Make event publishing lazier and defer object creation to fire phase.

### Todos

- [x] Add description to this pull request.
- [x] Add 3.8.1 vs. latest benchmark numbers.
- [ ] Add `ATTRS` mutation method to `Y.Base` which clears caches.
- [x] Fix minor issue in complex attribute values, e.g. "foo.bar".
- [ ] Fix issue with attribute value cloning of nodes in IE.
- [ ] Add API and user guide docs for changes.
- [x] Forecast minor back-compat breakage.