fix(loader): module.decorator order of operations is now irrelevant

`module.decorator` is now processed via the configBlocks order of operations and:
  1. no longer throws if declared before the provider being decorated
  2. guarantees the correct provider will be decorated when multiple, same-name providers
  are defined

(1) Prior to this fix, declaring `module.decorator` before the provider that it decorates
results in throwing an error:

```js
angular
  .module('theApp', [])
  .decorator('theFactory', theDecoratorFn)
  .factory('theFactory', theFactoryFn);

// Error: [$injector:modulerr] Failed to instantiate module theApp due to:
// Error: [$injector:unpr] Unknown provider: theFactoryProvider
```

The result of this fix now allows for the declaration order above.

(2) Prior to this fix, declaring `module.decorator` before the final, same-named provider
results in that provider **not** being decorated as expected:

**NOTE:** Angular does not use provider name spacing, so the final declared provider is
selected if multiple, same-named providers are declared.

```js
angular
  .module('theApp', [])
  .factory('theFactory', theFactoryFn)
  .decorator('theFactory', theDecoratorFn)
  .factory('theFactory', theOtherFactoryFn);

// `theOtherFactoryFn` is selected as 'theFactory' provider but it is **not** decorated
// via `theDecoratorFn` as expected
```

The result of this fix ensures that `theOtherFactoryFn` will be decorated as expected when
using the declaration order above.

BREAKING CHANGE:

`module.decorator` declarations are now processed as part of the `module.config` queue
and may result in providers being decorated in a different order if `module.config` blocks
are also used to decorate providers via `$provide.decorator`.

For example, consider the following declaration order in which 'theFactory' is decorated by
both a `module.decorator` and a `$provide.decorator`:

```js
angular
  .module('theApp', [])
  .factory('theFactory', theFactoryFn)
  .config(function($provide) {
    $provide.decorator('theFactory', anotherDecoratorFn);
  })
  .decorator('theFactory', theDecoratorFn);
```

Prior to this fix, 'theFactory' provider would be decorated in the following order:
  1. theDecoratorFn
  2. anotherDecoratorFn

The result of this fix changes the order in which 'theFactory' is decorated because
now `module.decorator` declarations are processed in the same order as `module.config`
declarations:
  1. anotherDecoratorFn
  2. theDecoratorFn

Closes #12382

Author: robertmirro

src/loader.js

@@ -203,7 +203,7 @@ function setupModuleLoader(window) {
            * @description
            * See {@link auto.$provide#decorator $provide.decorator()}.
            */
-          decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),
+          decorator: invokeLaterAndSetModuleName('$provide', 'decorator', configBlocks),
 
           /**
            * @ngdoc method
@@ -349,10 +349,11 @@ function setupModuleLoader(window) {
          * @param {string} method
          * @returns {angular.Module}
          */
-        function invokeLaterAndSetModuleName(provider, method) {
+        function invokeLaterAndSetModuleName(provider, method, queue) {
+          if (!queue) queue = invokeQueue;
           return function(recipeName, factoryFunction) {
             if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
-            invokeQueue.push([provider, method, arguments]);
+            queue.push([provider, method, arguments]);
             return moduleInstance;
           };
         }

test/loaderSpec.js

@@ -48,7 +48,6 @@ describe('module loader', function() {
     expect(myModule.requires).toEqual(['other']);
     expect(myModule._invokeQueue).toEqual([
       ['$provide', 'constant', jasmine.objectContaining(['abc', 123])],
-      ['$provide', 'decorator', jasmine.objectContaining(['dk', 'dv'])],
       ['$provide', 'provider', jasmine.objectContaining(['sk', 'sv'])],
       ['$provide', 'factory', jasmine.objectContaining(['fk', 'fv'])],
       ['$provide', 'service', jasmine.objectContaining(['a', 'aa'])],
@@ -60,6 +59,7 @@ describe('module loader', function() {
     ]);
     expect(myModule._configBlocks).toEqual([
       ['$injector', 'invoke', jasmine.objectContaining(['config'])],
+      ['$provide', 'decorator', jasmine.objectContaining(['dk', 'dv'])],
       ['$injector', 'invoke', jasmine.objectContaining(['init2'])]
     ]);
     expect(myModule._runBlocks).toEqual(['runBlock']);