Clean up some typos in GN quick start page.

tools/gn/docs/quick_start.md

 # GN Quick Start guide
 
 [TOC]
 
 ## Running GN
 
 You just run `gn` from the command line. There is a script in
 depot\_tools (which is presumably on your path) with this name. The
 script will find the binary in the source tree containing the current
 directory and run it.
@@ skipping 56 matching lines @@
 See [GNCrossCompiles](cross_compiles.md) for more info.
 
 ## Configuring goma
 
 
 Run `gn args out/Default` (substituting your build directory as needed).
 Add:
 
 ```
 use_goma = true
-goma_dir = "~/foo/bar/goma" 
+goma_dir = "~/foo/bar/goma"
 ```
 
 If your goma is in the default location (`~/goma`) then you can omit the
 `goma_dir` line.
 
 ## Configuring component mode
 
 This is a build arg like the goma flags. run `gn args out/Default` and add:
 
 ```
@@ skipping 10 matching lines @@
 executable("hello_world") {
   sources = [
     "hello_world.cc",
   ]
 }
 ```
 
 There should already be a `hello_world.cc` file in that directory,
 containing what you expect. That's it! Now we just need to tell the
 build about this file. Open the `BUILD.gn` file in the root directory
-and add the label of this target to the dependencies of the root group
-(a "group" target is a meta-target that is just a collection of other
-targets):
+and add the label of this target to the dependencies of one of the root
+groups (a "group" target is a meta-target that is just a collection of
+other targets):
 
 ```
 group("root") {
   deps = [
     ...
     "//url",
     "//tools/gn/tutorial:hello_world",
   ]
 }
 ```
@@ skipping 40 matching lines @@
 executable("say_hello") {
   sources = [
     "say_hello.cc",
   ]
   deps = [
     ":hello",
   ]
 }
 ```
 
-This executable includes one source file,and depends on the previous
+This executable includes one source file and depends on the previous
 static library. The static library is referenced by its label in the
 `deps`. You could have used the full label `//tools/gn/tutorial:hello`
 but if you're referencing a target in the same build file, you can use
 the shortcut `:hello`.
 
 ### Test the static library version
 
 From the command line in the source root directory:
 
 ```
 ninja -C out/Default say_hello
 out/Default/say_hello
 ```
 
-Note that you **didn't** need to re-run GN.GN will automatically rebuild
+Note that you **didn't** need to re-run GN. GN will automatically rebuild
 the ninja files when any build file has changed. You know this happens
 when ninja prints `[1/1] Regenerating ninja files` at the beginning of
 execution.
 
 ### Compiler settings
 
 Our hello library has a new feature, the ability to say hello to two
 people at once. This feature is controlled by defining `TWO_PEOPLE`. We
 can add defines like so:
 
@@ skipping 71 matching lines @@
 depend on your target (not transitively).
 
 Now if you compile and run, you'll see the new version with two people:
 
 ```
 > ninja -C out/Default say_hello
 ninja: Entering directory 'out/Default'
 [1/1] Regenerating ninja files
 [4/4] LINK say_hello
 > out/Default/say_hello
-Hello, Bill and Ted.
+Hello, Bill and Joy.
 ```
 
 ## Don't know what's going on?
 
 You can run GN in verbose mode to see lots of messages about what it's
 doing. Use `-v` for this.
 
 ### Print debugging
 
 There is a `print` command which just writes to stdout:
@@ skipping 47 matching lines @@
 line flag. This will output a summary of timings for various things.
 
 You can also make a trace of how the build files were executed:
 
 ```
 gn --tracelog=mylog.trace
 ```
 
 and you can load the resulting file in Chrome's `about:tracing` page to
 look at everything.