Guide: pointers

This is the next section of the guide, and it's on pointers. It's not done yet, as I need to write the section on ownership and borrowing, but I figured I'd share the rest now, to get feedback on the rest of it while I take some time to get that right.
I like this explanation a lot less than other explanations. the only way I know how to criticize explanations is to rewrite them. this isn't meant as an insult or anything :). mostly I removed things that I didn't think were necessary to understand the concepts (like 'affine type' and 'Box<T>')

All of our references so far have been to variables we've created on the stack. In Rust, the simplest way to allocate heap variables is using a *box*, sometimes called a *boxed pointer*. 
To create a box, use the `box` keyword:
 
 ```{rust}
 let x = box 5i;
 ```

This allocates a variable `x` on the heap, containing the integer 5. The great thing about boxed pointers is that we don't have to manually free this allocation! If we write 

```{rust}
{
     let x = box 5i;
     // do stuff
 }
```

then Rust will automatically free `x` at the end of the block. This isn't because Rust has a garbage collector -- it doesn't. Instead, Rust uses static analysis to determine the *lifetime* of `x`, and then generates code to free it once it's sure the `x` won't be used again. This Rust code will do the same thing as the following C code:

```{c,ignore}
 {
     int *x = (int *)malloc(sizeof(int));
     // do stuff
     free(x);
 }
```