[Performance] MISC micro performance improvments

Motivation:

things that are cached should be as close to free to retrieve as possible, this PR targets cached CP values.

- [x] improve Ember.cacheFor throughput see: http://jsperf.com/fffffffffffffffff1111a/2
- [x] improve throughput of get of a cached CP see: http://jsperf.com/slow-get-fast-get
- [x] [Performance] improve META lookup 10x throughput on chrome 32/34 [homework](https://gist.github.com/stefanpenner/ede92fbd00bf49bc5f09) + [benchmarks](http://jsperf.com/lookup-key-length/2)
- [x] [Performance] minimize extra indexOf hits in Ember.get
- [x] before/after high level benchmark
- [x] open a [ticket on v8/chrome](https://code.google.com/p/v8/issues/detail?id=3144&thanks=3144&ts=1391994334) RE: concat string perf hit. 
- [x] improve CP set's 2 - 5X by repeating similar patterns on the set side of things.
- [x] explore killing all code that deletes from the meta cache. (this object may always be stuck in dict mode..)
- [ ] open ticket on V8 (maybe the rest of the vendors) regarding the cost of getting `function.length`

- [x] although tests pass, reduce computed will likely break in some places until I patch it

outcomes:
-------------

getting a cached CP, appears to be now between 2x and 5x faster
setting a cached CP, appears to be now between 2x and 5x faster
some other aspects of CP's may also be improved.

complete un-scientific MICRO benchmark (I ran out of time):

given:
```js
a = Ember.Object.createWithMixins({
  foo: Ember.computed(function() {
    return 'hi';
  })
});

a.get("foo"); // prime
b = {
  foo: 'hi'
};

function test(){
  console.time('cp');
  for ( var i = 0; i < 100000; i++ ){
    Ember.get(a, 'foo');
  }
  console.timeEnd('cp');
}
```

before this PR:
```sh
test() => cp: 54.936ms
test() => cp: 42.300ms
test() => cp: 33.344ms
test() => cp: 32.220ms
test() => cp: 55.750ms
test() => cp: 38.422ms
```

with this PR
```sh
test() => cp: 5.886ms
test() => cp: 4.363ms
test() => cp: 4.474ms 
test() => cp: 4.658ms
test() => cp: 6.384ms
test() => cp: 4.420ms
```

Nothing ground breaking, we can likely improve this more yet, we really need a better perf harness.. (cc @twokul)

Also, I was careful to ensure these changes didn't drastically degrade other paths. Other code-paths, especially ones utilizing meta should now be quicker, and generate much less garbage.