doc (book)[05/14]: "Cargo Guide"/"Why Cargo Exists": add "Preliminaries"

The "Why Cargo Exists" section of the "Cargo Guide" is here split
into two subsections:

    "Preliminaries"
    "Enter: Cargo"

The content in "Preliminaries" is new, and provides a transition
that motivates the need for a package manager rather than using
'rustc' directly. It provides footing for the reader that knows very
little about Rust and nothing about Cargo.

The "Enter: Cargo" subsection contains the previous content,
augmented with a new paragraph explaining how the conventional list
of build targets simplifies working with Cargo packages: "...once
you know how to build one Cargo-based project, you know how to build
/all/ of them."

The following terms are linked to their Glossary entries:
    - artifact
    - crate
    - package
    - package manager
    - registry

Author: salewski

src/doc/src/guide/why-cargo-exists.md

@@ -1,7 +1,41 @@
 ## Why Cargo Exists
 
-Cargo is a tool that allows Rust packages to declare their various
-dependencies and ensure that you’ll always get a repeatable build.
+### Preliminaries
+
+In Rust, as you may know, a library or executable program is called a
+[*crate*][def-crate]. Crates are compiled using the Rust compiler,
+`rustc`. When starting with Rust, the first source code most people encounter
+is that of the venerable “hello world” program, which they compile by invoking
+`rustc` directly:
+
+```console
+$ rustc hello.rs
+$ ./hello
+Hello, world!
+```
+
+Note that the above command required that we specify the file name
+explicitly. If we were to directly use `rustc` to compile a different program,
+a different command line invocation would be required. If we needed to specify
+any specific compiler flags or include external dependencies, then the
+needed command would be even more specific (and elaborate).
+
+Furthermore, most non-trivial programs will likely have dependencies on
+external libraries, and will therefore also depend transitively on *their*
+dependencies. Obtaining the correct versions of all the necessary dependencies
+and keeping them up to date would be laborious and error-prone if done by
+hand.
+
+Rather than work only with crates and `rustc`, we can avoid the manual tedium
+involved with performing the above tasks by introducing a higher-level
+["*package*"][def-package] abstraction and by using a
+[*package manager*][def-package-manager].
+
+### Enter: Cargo
+
+*Cargo* is the Rust package manager. It is a tool that allows Rust
+[*packages*][def-package] to declare their various dependencies and ensure
+that you’ll always get a repeatable build.
 
 To accomplish this goal, Cargo does four things:
 
@@ -10,3 +44,22 @@ To accomplish this goal, Cargo does four things:
 * Invokes `rustc` or another build tool with the correct parameters to build
   your package.
 * Introduces conventions to make working with Rust packages easier.
+
+To a large extent, Cargo normalizes the commands needed to build a given
+program or library; this is one aspect to the above mentioned conventions. As
+we show later, the same command can be used to build different
+[*artifacts*][def-artifact], regardless of their names. Rather than invoke
+`rustc` directly, we can instead invoke something generic such as `cargo
+build` and let cargo worry about constructing the correct `rustc`
+invocation. Furthermore, Cargo will automatically fetch from a
+[*registry*][def-registry] any dependencies we have defined for our artifact,
+and arrange for them to be incorporated into our build as needed.
+
+It is only a slight exageration to say that once you know how to build one
+Cargo-based project, you know how to build *all* of them.
+
+[def-artifact]:         ../appendix/glossary.md#artifact         '"artifact" (glossary entry)'
+[def-crate]:            ../appendix/glossary.md#crate            '"crate" (glossary entry)'
+[def-package]:          ../appendix/glossary.md#package          '"package" (glossary entry)'
+[def-package-manager]:  ../appendix/glossary.md#package-manager  '"package manager" (glossary entry)'
+[def-registry]:         ../appendix/glossary.md#registry         '"registry" (glossary entry)'