refactor(nodeName_): remove IE8 specific branch
perf(nodeName_): simplify the code and reduce the number of DOM calls
refactor(hashKey): don't generate memory garbage

we now store both the object type and the id as the hashkey and return it for all objects.

for primitives we still have to do string concatination because we can't use expandos on them to
store the hashkey
fix(ngModel): treat undefined parse responses as parse errors

With this commit, ngModel will now handle parsing first and then validation
afterwards once the parsing is successful. If any parser along the way returns
`undefined` then ngModel will break the chain of parsing and register a
a parser error represented by the type of input that is being collected
(e.g. number, date, datetime, url, etc...). If a parser fails for a standard
text input field then an error of `parse` will be placed on `model.$error`.

BREAKING CHANGE

Any parser code from before that returned an `undefined` value
(or nothing at all) will now cause a parser failure. When this occurs
none of the validators present in `$validators` will run until the parser
error is gone.
feat(ngModel): provide validation API functions for sync and async validations

This commit introduces a 2nd validation queue called `$asyncValidators`. Each time a value
is processed by the validation pipeline, if all synchronous `$validators` succeed, the value
is then passed through the `$asyncValidators` validation queue. These validators should return
a promise. Rejection of a validation promise indicates a failed validation.
feat($rootScope): implement $applyAsync to support combining calls to $apply into a single digest.

It is now possible to queue up multiple expressions to be evaluated in a single digest using
$applyAsync. The asynchronous expressions will be evaluated either 1) the next time $apply or
$rootScope.$digest is called, or 2) after after the queue flushing scheduled for the next turn
occurs (roughly ~10ms depending on browser and application).
feat($http): implement mechanism for coalescing calls to $apply in $http

When multiple responses are received within a short window from each other, it can be wasteful to
perform full dirty-checking cycles for each individual response. In order to prevent this, it is
now possible to coalesce calls to $apply for responses which occur close together.

This behaviour is opt-in, and the default is disabled, in order to avoid breaking tests or
applications.

In order to activate coalesced apply in tests or in an application, simply perform the following
steps during configuration.

   angular.module('myFancyApp', []).
     config(function($httpProvider) {
       $httpProvider.useApplyAsync(true);
     });

OR:

   angular.mock.module(function($httpProvider) {
     $httpProvider.useApplyAsync(true);
   });

Closes #8736
Closes #7634
Closes #5297
docs(shallowCopy): add missing word 'are' and period.

Closes #8794
fix(Angular): remove duplicate nodeName_ references

I forgot to remove the variable declaration in previous nodeName_ commit.
chore(build): uprade closure-compiler to v20140814

no significant change in code size
docs(compile): `translcuded` -> `transcluded`

Oops.

Closes #8799
fix($browser): detect changes to the browser url that happened in sync

Closes #6976.