Rollup merge of rust-lang#24178 - steveklabnik:new_toc, r=nikomatsakis

Basically, the overall structure is this:

* Getting Started - getting an environment up and running
* Learn Rust - project-based learning the basics
* Effective Rust - higher level concepts that lead to writing good rust
* Syntax and Semantics - chunks of exactly what it sounds like
* Nightly Rust - unstable stuff, a staging area for documenting features
* Glossary - self-explanatory

There's a number of weaknesses with the current TOC, but I'll just focus on the strengths of the new one:

We start off with getting our environment set up. That's "getting started".

Then, we basically present you with two choices: do you want to start small, with bits of syntax? Or do you want to dive in with projects?

I'm guessing more people will choose the second, so that's the next part: "Learn Rust." I don't have any chapters here, but this would have an updated guessing game, a tutorial on building a little `wc` clone, and something else I haven't decided yet. Lots of options. But the idea is to just dive in and get your hands dirty. I'll heavily link to the 'syntax and semantics' sections that are relevant.

Then, a section I'm calling 'Effective Rust'. it feels greedy to steal that title, so I'm hoping to give it another name. These are higher-level things than syntax that Rust programmers should know: error handling is a great example. Most of these are sort of 'how do I use the standard library together' kinds of things. This also contains informations about systems programming that those new to it might not know: the stack vs the heap, for example.

Then, "Syntax and Semantics." This has one section for each bit of Rust. Small, focused, but explains _everything_. These are positioned to be almost entirely in-order, but heavily cross-link, so you can go out of order if you want to, but you can also use it as a reference.

Next, "Nightly Rust," where documenting unstable things goes. If we want to get good feedback on new features, they'll need to be documented, but we don't want to taint the main docs, so that's what this is for.

Finally, the glossary. Straightforward enough.

--------------------------------

This is going to be a terrible PR to review, so I just did the TOC re-organization, with basically no editing. So it'll be a bit jumbled at first. But next steps are to go through and edit / revise / tweak / add stuff to get it in tip-top shape for 1.0!

Author: steveklabnik

src/doc/trpl/SUMMARY.md

@@ -1,48 +1,69 @@
 # Summary
 
-* [The Basics](basic.md)
+* [Getting Started](getting-started.md)
     * [Installing Rust](installing-rust.md)
     * [Hello, world!](hello-world.md)
     * [Hello, Cargo!](hello-cargo.md)
+* [Learn Rust](learn-rust.md)
+* [Effective Rust](effective-rust.md)
+    * [The Stack and the Heap](the-stack-and-the-heap.md)
+    * [`Debug` and `Display`](debug-and-display.md)
+    * [Testing](testing.md)
+    * [Documentation](documentation.md)
+    * [Iterators](iterators.md)
+    * [Concurrency](concurrency.md)
+    * [Error Handling](error-handling.md)
+    * [FFI](ffi.md)
+    * [`Deref` coercions](deref-coercions.md)
+* [Syntax and Semantics](syntax-and-semantics.md)
     * [Variable Bindings](variable-bindings.md)
-    * [If](if.md)
+    * [Primitive Types](primitive-types.md)
     * [Functions](functions.md)
     * [Comments](comments.md)
-    * [Compound Data Types](compound-data-types.md)
+    * [Structs](structs.md)
+    * [Mutability](mutability.md)
+    * [Method Syntax](method-syntax.md)
+    * [Enums](enums.md)
+    * [`if`](if.md)
     * [Match](match.md)
-    * [Looping](looping.md)
+    * [Patterns](patterns.md)
+    * [`for` loops](for-loops.md)
+    * [`while` loops](while-loops.md)
+    * [Ownership](ownership.md)
+    * [References and Borrowing](references-and-borrowing.md)
+    * [Lifetimes](lifetimes.md)
+    * [Move semantics](move-semantics.md)
+    * [Drop](drop.md)
+    * [Vectors](vectors.md)
+    * [Arrays](arrays.md)
+    * [Slices](slices.md)
     * [Strings](strings.md)
-    * [Arrays, Vectors, and Slices](arrays-vectors-and-slices.md)
-* [Intermediate Rust](intermediate.md)
+    * [Traits](traits.md)
+    * [Operators and Overloading](operators-and-overloading.md)
+    * [Generics](generics.md)
+    * [Trait Objects](trait-objects.md)
+    * [Closures](closures.md)
+    * [Universal Function Call Syntax](ufcs.md)
     * [Crates and Modules](crates-and-modules.md)
-    * [Testing](testing.md)
-    * [Pointers](pointers.md)
-    * [Ownership](ownership.md)
-    * [More Strings](more-strings.md)
-    * [Patterns](patterns.md)
-    * [Method Syntax](method-syntax.md)
+    * [`static`](static.md)
+    * [`const`](const.md)
+    * [Tuples](tuples.md)
+    * [Tuple Structs](tuple-structs.md)
+    * [Attributes](attributes.md)
+    * [Conditional Compilation](conditional-compilation.md)
+    * [`type` aliases](type-aliases.md)
+    * [Casting between types](casting-between-types.md)
     * [Associated Types](associated-types.md)
-    * [Closures](closures.md)
-    * [Iterators](iterators.md)
-    * [Generics](generics.md)
-    * [Traits](traits.md)
-    * [Static and Dynamic Dispatch](static-and-dynamic-dispatch.md)
+    * [Unsized Types](unsized-types.md)
     * [Macros](macros.md)
-    * [Concurrency](concurrency.md)
-    * [Error Handling](error-handling.md)
-    * [Documentation](documentation.md)
-* [Advanced Topics](advanced.md)
-    * [FFI](ffi.md)
-    * [Unsafe Code](unsafe.md)
-    * [Advanced Macros](advanced-macros.md)
-* [Unstable Rust](unstable.md)
-    * [Compiler Plugins](plugins.md)
+    * [`unsafe` Code](unsafe-code.md)
+* [Nightly Rust](nightly-rust.md)
+    * [Compiler Plugins](compiler-plugins.md)
     * [Inline Assembly](inline-assembly.md)
     * [No stdlib](no-stdlib.md)
     * [Intrinsics](intrinsics.md)
     * [Lang items](lang-items.md)
     * [Link args](link-args.md)
     * [Benchmark Tests](benchmark-tests.md)
     * [Box Syntax and Patterns](box-syntax-and-patterns.md)
-* [Conclusion](conclusion.md)
 * [Glossary](glossary.md)