Cleanup references to concurrent_links in gn binary.

tools/gn/docs/reference.md

 # GN Reference
 
 *This page is automatically generated from* `gn help --markdown all`.
 
 ## **\--args**: Specifies build arguments overrides.
 
 ```
   See "gn help buildargs" for an overview of how build arguments work.
 
   Most operations take a build directory. The build arguments are taken
@@ skipping 2004 matching lines @@
 
       The result will never end in a slash, so if the resulting
       is empty, the system ("/") or source ("//") roots, a "."
       will be appended such that it is always legal to append a slash
       and a filename and get a valid path.
 
   "out_dir"
       The output file directory corresponding to the path of the
       given file, not including a trailing slash.
         "//foo/bar/baz.txt" => "//out/Default/obj/foo/bar"
+
   "gen_dir"
       The generated file directory corresponding to the path of the
       given file, not including a trailing slash.
         "//foo/bar/baz.txt" => "//out/Default/gen/foo/bar"
 
   "abspath"
       The full absolute path name to the file or directory. It will be
       resolved relative to the current directory, and then the source-
       absolute version will be returned. If the input is system-
       absolute, the same input will be returned.
@@ skipping 1395 matching lines @@
     dependencies these must be targets defined in another toolchain.
 
     This is expressed as a list of targets, and generally these targets
     will always specify a toolchain:
       deps = [ "//foo/bar:baz(//build/toolchain:bootstrap)" ]
 
     This concept is somewhat inefficient to express in Ninja (it
     requires a lot of duplicate of rules) so should only be used when
     absolutely necessary.
 
-  concurrent_links
-    In integer expressing the number of links that Ninja will perform in
-    parallel. GN will create a pool for shared library and executable
-    link steps with this many processes. Since linking is memory- and
-    I/O-intensive, projects with many large targets may want to limit
-    the number of parallel steps to avoid overloading the computer.
-    Since creating static libraries is generally not as intensive
-    there is no limit to "alink" steps.
-
-    Defaults to 0 which Ninja interprets as "no limit".
-
-    The value used will be the one from the default toolchain of the
-    current build.
-
 ```
 
 ### **Invoking targets in toolchains**:
 
 ```
   By default, when a target depends on another, there is an implicit
   toolchain label that is inherited, so the dependee has the same one
   as the dependent.
 
   You can override this and refer to any other toolchain by explicitly
@@ skipping 10 matching lines @@
       arguments specified by the toolchain_args section of the toolchain
       definition (see "gn help toolchain_args").
    3. Loads the destination build file in the context of the
       configuration file in the previous step.
 
 ```
 
 ### **Example**:
 ```
   toolchain("plugin_toolchain") {
-    concurrent_links = 8
-
     tool("cc") {
       command = "gcc {{source}}"
       ...
     }
 
     toolchain_args() {
       is_plugin = true
       is_32bit = true
       is_64bit = false
     }
@@ skipping 2840 matching lines @@
 **  \--root**: Explicitly specify source root.
 **  \--runtime-deps-list-file**: Save runtime dependencies for targets in file.
 **  \--script-executable**: Set the executable used to execute scripts.
 **  \--threads**: Specify number of worker threads.
 **  \--time**: Outputs a summary of how long everything took.
 **  \--tracelog**: Writes a Chrome-compatible trace log to the given file.
 **  -v**: Verbose logging.
 **  \--version**: Prints the GN version number and exits.
 
 ```