docs: correct broken links

This also contains some whitespace corrections by my editor.

docs/content/cookbook/mvc.ngdoc

@@ -125,4 +125,4 @@ board variable.
 * The view can call any controller function.
 * In this example, the `setUrl()` and `readUrl()` functions copy the game state to/from the URL's
 hash so the browser's back button will undo game steps. See deep-linking. This example calls {@link
-api/ng.$rootScope.Scope#$watch $watch()} to set up a listener that invokes `readUrl()` when needed.
+api/ng.$rootScope.Scope#methods_$watch $watch()} to set up a listener that invokes `readUrl()` when needed.

docs/content/error/compile/ctreq.ngdoc

@@ -3,7 +3,7 @@
 @fullName Missing Required Controller
 @description
 
-This error occurs when {@link api/ng.$compile template compiler} tries process the directive that specifies the `require` option in a {@link guide/directive#directivedefinitionobject directive definition},
+This error occurs when {@link api/ng.$compile template compiler} tries process the directive that specifies the `require` option in a {@link guide/directive#writing-directives_directive-definition-object directive definition},
 but the required directive controller is not present on the current DOM element (or its ancestor element, if `^` was specified).
 
 To resolve this error ensure that there is no typo in the required controller name and that the required directive controller is present on the current element.

docs/content/error/compile/iscp.ngdoc

@@ -21,4 +21,4 @@ myModule.directive('directiveName', function factory() {
 });
 ```
 
-Please refer to the {@link guide/directive#directivedefinitionobject directive definition docs} to learn more about the api.
+Please refer to the {@link guide/directive#writing-directives_directive-definition-object directive definition docs} to learn more about the api.

docs/content/error/compile/nonassign.ngdoc

@@ -3,7 +3,7 @@
 @fullName Non-Assignable Expression
 @description
 
-This error occurs when a directive defines an isolate scope property that support two-way data-binding (using the `=` mode in the {@link guide/directive#directivedefinitionobject  directive definition}) but the directive is used with an expression that is not-assignable.
+This error occurs when a directive defines an isolate scope property that support two-way data-binding (using the `=` mode in the {@link guide/directive#writing-directives_directive-definition-object  directive definition}) but the directive is used with an expression that is not-assignable.
 
 In order for the two-way data-binding to work, it must be possible to write new values back into the path defined with the expression.
 

docs/content/error/injector/pget.ngdoc

@@ -22,5 +22,5 @@ angular.module("myApp", [])
   .provider('good', GoodProvider);
 ```
 
-For more information, refer to the {@link api/AUTO.$provide#provider
+For more information, refer to the {@link api/AUTO.$provide#methods_provider
 $provide.provider} api doc.

docs/content/error/jqLite/nosel.ngdoc

@@ -3,7 +3,7 @@
 @fullName Unsupported Selector Lookup
 @description
 
-In order to keep Angular small, Angular implements only a subset of the selectors in {@link api/angular.element#angularsjqlite jqLite}.
+In order to keep Angular small, Angular implements only a subset of the selectors in {@link api/angular.element#description_angulars-jqlite jqLite}.
 This error occurs when a jqLite instance is invoked with a selector other than this subset.
 
 In order to resolve this error, rewrite your code to only use tag name selectors and manually traverse the DOM using the APIs provided by jqLite.

docs/content/error/sce/icontext.ngdoc

@@ -3,6 +3,6 @@
 @fullName Invalid / Unknown SCE context
 @description
 
-The context enum passed to {@link api/ng.$sce#trustAs $sce.trustAs} was not recognized.
+The context enum passed to {@link api/ng.$sce#methods_trustAs $sce.trustAs} was not recognized.
 
 Please consult the list of {@link api/ng.$sce#contexts supported Strict Contextual Escaping (SCE) contexts}.

docs/content/error/sce/iequirks.ngdoc

@@ -3,7 +3,7 @@
 @fullName IE8 in quirks mode is unsupported
 @description
 
-This error occurs when you are using AngularJS with {@link api/ng.$sce#strictcontextualescaping Strict Contextual Escaping (SCE)} mode enabled (the default) on IE8 or lower in quirks mode.
+This error occurs when you are using AngularJS with {@link api/ng.$sce Strict Contextual Escaping (SCE)} mode enabled (the default) on IE8 or lower in quirks mode.
 
 In this mode, IE8 allows one to execute arbitrary javascript by the use of the `expression()` syntax and is not supported.
 Refer {@link http://blogs.msdn.com/b/ie/archive/2008/10/16/ending-expressions.aspx MSDN Blogs > IEBlog > Ending Expressions} to learn more about them.

docs/content/error/sce/imatcher.ngdoc

@@ -3,7 +3,7 @@
 @fullName Invalid matcher (only string patterns and RegExp instances are supported)
 @description
 
-Please see {@link api/ng.$sceDelegateProvider#resourceUrlWhitelist
+Please see {@link api/ng.$sceDelegateProvider#methods_resourceUrlWhitelist
 $sceDelegateProvider.resourceUrlWhitelist} and {@link
-api/ng.$sceDelegateProvider#resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} for the
+api/ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} for the
 list of acceptable items.

docs/content/error/sce/insecurl.ngdoc

@@ -3,21 +3,21 @@
 @fullName Processing of a Resource from Untrusted Source Blocked
 @description
 
-AngularJS' {@link api/ng.$sce#strictcontextualescaping Strict Contextual Escaping (SCE)} mode (enabled by default) has blocked loading a resource from an insecure URL.
+AngularJS' {@link api/ng.$sce Strict Contextual Escaping (SCE)} mode (enabled by default) has blocked loading a resource from an insecure URL.
 
 Typically, this would occur if you're attempting to load an Angular template from an untrusted source.
 It's also possible that a custom directive threw this error for a similar reason.
 
-Angular only loads templates from trusted URLs (by calling {@link api/ng.$sce#getTrustedResourceUrl $sce.getTrustedResourceUrl} on the template URL).
+Angular only loads templates from trusted URLs (by calling {@link api/ng.$sce#methods_getTrustedResourceUrl $sce.getTrustedResourceUrl} on the template URL).
 
 By default, only URLs that belong to the same origin are trusted. These are urls with the same domain and protocol as the application document.
 
 The {@link api/ng.directive:ngInclude ngInclude} directive and {@link guide/directive directives} that specify a `templateUrl` require a trusted resource URL.
 
 To load templates from other domains and/or protocols, either adjust the {@link
-api/ng.$sceDelegateProvider#resourceUrlWhitelist whitelist}/ {@link
-api/ng.$sceDelegateProvider#resourceUrlBlacklist blacklist} or wrap the URL with a call to {@link
-api/ng.$sce#trustAsResourceUrl $sce.trustAsResourceUrl}.
+api/ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelist}/ {@link
+api/ng.$sceDelegateProvider#methods_resourceUrlBlacklist blacklist} or wrap the URL with a call to {@link
+api/ng.$sce#methods_trustAsResourceUrl $sce.trustAsResourceUrl}.
 
 **Note**: The browser's {@link
 https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest Same Origin

docs/content/error/sce/itype.ngdoc

@@ -3,6 +3,6 @@
 @fullName String Value is Required for SCE Trust Call
 @description
 
-{@link api/ng.$sce#trustAs $sce.trustAs} requires a string value.
+{@link api/ng.$sce#methods_trustAs $sce.trustAs} requires a string value.
 
-Read more about {@link api/ng.$sce#strictcontextualescaping Strict Contextual Escaping (SCE)} in AngularJS.
+Read more about {@link api/ng.$sce Strict Contextual Escaping (SCE)} in AngularJS.

docs/content/error/sce/iwcard.ngdoc

@@ -3,7 +3,7 @@
 @fullName The sequence *** is not a valid pattern wildcard
 @description
 
-The strings in {@link api/ng.$sceDelegateProvider#resourceUrlWhitelist
+The strings in {@link api/ng.$sceDelegateProvider#methods_resourceUrlWhitelist
 $sceDelegateProvider.resourceUrlWhitelist} and {@link
-api/ng.$sceDelegateProvider#resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} may not
+api/ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} may not
 contain the undefined sequence `***`.  Only `*` and `**` wildcard patterns are defined.

docs/content/error/sce/unsafe.ngdoc

@@ -5,11 +5,11 @@
 
 The value provided for use in a specific context was not found to be safe/trusted for use.
 
-Angular's {@link api/ng.$sce#strictcontextualescaping Strict Contextual Escaping (SCE)} mode
+Angular's {@link api/ng.$sce Strict Contextual Escaping (SCE)} mode
 (enabled by default), requires bindings in certain
 contexts to result in a value that is trusted as safe for use in such a context.  (e.g. loading an
 Angular template from a URL requires that the URL is one considered safe for loading resources.)
 
 This helps prevent XSS and other security issues.  Read more at {@link
-api/ng.$sce#strictcontextualescaping Strict Contextual Escaping (SCE)}
+api/ng.$sce Strict Contextual Escaping (SCE)}
 

docs/content/guide/animations.ngdoc

@@ -253,13 +253,13 @@ The table below explains in detail which animation events are triggered
 
 | Directive                                                                           | Supported Animations                     |
 |-------------------------------------------------------------------------------------|------------------------------------------|
-| {@link api/ng.directive:ngRepeat#animations ngRepeat}                               | enter, leave, and move                   |
-| {@link api/ngRoute.directive:ngView#animations ngView}                              | enter and leave                          |
-| {@link api/ng.directive:ngInclude#animations ngInclude}                             | enter and leave                          |
-| {@link api/ng.directive:ngSwitch#animations ngSwitch}                               | enter and leave                          |
-| {@link api/ng.directive:ngIf#animations ngIf}                                       | enter and leave                          |
-| {@link api/ng.directive:ngShow#animations ngClass or {{class}}} | add and remove                           |
-| {@link api/ng.directive:ngShow#animations ngShow & ngHide}                          | add and remove (the ng-hide class value) |
+| {@link api/ng.directive:ngRepeat#usage_animations ngRepeat}                               | enter, leave, and move                   |
+| {@link api/ngRoute.directive:ngView#usage_animations ngView}                              | enter and leave                          |
+| {@link api/ng.directive:ngInclude#usage_animations ngInclude}                             | enter and leave                          |
+| {@link api/ng.directive:ngSwitch#usage_animations ngSwitch}                               | enter and leave                          |
+| {@link api/ng.directive:ngIf#usage_animations ngIf}                                       | enter and leave                          |
+| {@link api/ng.directive:ngShow#usage_animations ngClass or {{class}}} | add and remove                           |
+| {@link api/ng.directive:ngShow#usage_animations ngShow & ngHide}                          | add and remove (the ng-hide class value) |
 
 For a full breakdown of the steps involved during each animation event, refer to the {@link api/ngAnimate.$animate API docs}.
 

docs/content/guide/compiler.ngdoc

@@ -7,7 +7,7 @@
 Angular's {@link api/ng.$compile HTML compiler} allows the developer to teach the
 browser new HTML syntax. The compiler allows you to attach behavior to any HTML element or attribute
 and even create new HTML elements or attributes with custom behavior. Angular calls these behavior
-extensions {@link api/ng.$compileProvider#directive directives}.
+extensions {@link api/ng.$compileProvider#methods_directive directives}.
 
 HTML has a lot of constructs for formatting the HTML for static documents in a declarative fashion.
 For example if something needs to be centered, there is no need to provide instructions to the
@@ -59,7 +59,7 @@ api/ng.directive:ngBind `ng-bind`} directive.
 </pre>
 
 A directive is just a function which executes when the compiler encounters it in the DOM. See {@link
-api/ng.$compileProvider#directive directive API} for in-depth documentation on how
+api/ng.$compileProvider#methods_directive directive API} for in-depth documentation on how
 to write directives.
 
 Here is a directive which makes any element draggable. Notice the `draggable` attribute on the

docs/content/guide/concepts.ngdoc

@@ -75,26 +75,26 @@ directive which is handling the event. An explicit call to $apply is needed only
 implementing custom event callbacks, or when working with third-party library callbacks.
 
   1. Enter Angular execution context by calling {@link guide/scope scope}`.`{@link
-     api/ng.$rootScope.Scope#$apply $apply}`(stimulusFn)`. Where `stimulusFn` is
+     api/ng.$rootScope.Scope#methods_$apply $apply}`(stimulusFn)`. Where `stimulusFn` is
      the work you wish to do in Angular execution context.
   2. Angular executes the `stimulusFn()`, which typically modifies application state.
-  3. Angular enters the {@link api/ng.$rootScope.Scope#$digest $digest} loop. The
+  3. Angular enters the {@link api/ng.$rootScope.Scope#methods_$digest $digest} loop. The
      loop is made up of two smaller loops which process {@link
-     api/ng.$rootScope.Scope#$evalAsync $evalAsync} queue and the {@link
-     api/ng.$rootScope.Scope#$watch $watch} list. The {@link
-     api/ng.$rootScope.Scope#$digest $digest} loop keeps iterating until the model
-     stabilizes, which means that the {@link api/ng.$rootScope.Scope#$evalAsync
-     $evalAsync} queue is empty and the {@link api/ng.$rootScope.Scope#$watch
+     api/ng.$rootScope.Scope#methods_$evalAsync $evalAsync} queue and the {@link
+     api/ng.$rootScope.Scope#methods_$watch $watch} list. The {@link
+     api/ng.$rootScope.Scope#methods_$digest $digest} loop keeps iterating until the model
+     stabilizes, which means that the {@link api/ng.$rootScope.Scope#methods_$evalAsync
+     $evalAsync} queue is empty and the {@link api/ng.$rootScope.Scope#methods_$watch
      $watch} list does not detect any changes.
-  4. The {@link api/ng.$rootScope.Scope#$evalAsync $evalAsync} queue is used to
+  4. The {@link api/ng.$rootScope.Scope#methods_$evalAsync $evalAsync} queue is used to
      schedule work which needs to occur outside of current stack frame, but before the browser's
      view render. This is usually done with `setTimeout(0)`, but the `setTimeout(0)` approach
      suffers from slowness and may cause view flickering since the browser renders the view after
      each event.
-  5. The {@link api/ng.$rootScope.Scope#$watch $watch} list is a set of expressions
+  5. The {@link api/ng.$rootScope.Scope#methods_$watch $watch} list is a set of expressions
      which may have changed since last iteration. If a change is detected then the `$watch`
      function is called which typically updates the DOM with the new value.
-  6. Once the Angular {@link api/ng.$rootScope.Scope#$digest $digest} loop finishes
+  6. Once the Angular {@link api/ng.$rootScope.Scope#methods_$digest $digest} loop finishes
      the execution leaves the Angular and JavaScript context. This is followed by the browser
      re-rendering the DOM to reflect any changes.
 
@@ -107,17 +107,17 @@ user enters text into the text field.
         api/ng.directive:input input} {@link guide/directive
         directive} set up a `keydown` listener on the `<input>` control.
      2. the {@link api/ng.$interpolate &#123;&#123;name&#125;&#125; } interpolation
-        sets up a {@link api/ng.$rootScope.Scope#$watch $watch} to be notified of
+        sets up a {@link api/ng.$rootScope.Scope#methods_$watch $watch} to be notified of
         `name` changes.
   2. During the runtime phase:
      1. Pressing an '`X`' key causes the browser to emit a `keydown` event on the input control.
      2. The {@link api/ng.directive:input input} directive
         captures the change to the input's value and calls {@link
-        api/ng.$rootScope.Scope#$apply $apply}`("name = 'X';")` to update the
+        api/ng.$rootScope.Scope#methods_$apply $apply}`("name = 'X';")` to update the
         application model inside the Angular execution context.
      3. Angular applies the `name = 'X';` to the model.
-     4. The {@link api/ng.$rootScope.Scope#$digest $digest} loop begins
-     5. The {@link api/ng.$rootScope.Scope#$watch $watch} list detects a change
+     4. The {@link api/ng.$rootScope.Scope#methods_$digest $digest} loop begins
+     5. The {@link api/ng.$rootScope.Scope#methods_$watch $watch} list detects a change
         on the `name` property and notifies the {@link api/ng.$interpolate
         &#123;&#123;name&#125;&#125; } interpolation, which in turn updates the DOM.
      6. Angular exits the execution context, which in turn exits the `keydown` event and with it
@@ -253,7 +253,7 @@ rendering the view compared to most other templating systems.
     template sprinkled in.) The browser parses the HTML into the DOM, and the DOM becomes the input to
     the template engine known as the {@link api/ng.$compile compiler}. The compiler
     looks for {@link guide/directive directives} which in turn set up {@link
-    api/ng.$rootScope.Scope#$watch watches} on the model. The result is a
+    api/ng.$rootScope.Scope#methods_$watch watches} on the model. The result is a
     continuously updating view which does not need template model re-merging. Your model becomes
     the single source-of-truth for your view.
 
@@ -377,8 +377,8 @@ as a {@link api/AUTO.$provide provider}.
 
 
 But the real magic of the {@link api/AUTO.$injector injector} is that it can be
-used to {@link api/AUTO.$injector#invoke call} methods and {@link
-api/AUTO.$injector#instantiate instantiate} types. This subtle feature is what
+used to {@link api/AUTO.$injector#methods_invoke call} methods and {@link
+api/AUTO.$injector#methods_instantiate instantiate} types. This subtle feature is what
 allows the methods and types to ask for their dependencies instead of having to look for them.
 
 <pre>
@@ -406,7 +406,7 @@ allows the methods and types to ask for their dependencies instead of having to
 
 Notice that the only thing you needed to write was the function, and list the dependencies in the
 function arguments. When angular calls the function, it will use the {@link
-api/AUTO.$injector#invoke call} which will automatically fill the function
+api/AUTO.$injector#methods_invoke call} which will automatically fill the function
 arguments.
 
 Examine the `ClockCtrl` below, and notice how it lists the dependencies in the constructor. When the