Ownership guide

This is a work in progress, but this should get *extensive* review, so I'm putting it up early and often.

This is the start of a draft of the new 'ownership guide,' which explains ownership, borrowing, etc. I'm feeling better about this framing than last time's, but we'll see.
When going though the aforementioned lifetime problems I tried to dig around the interwebs to figure out exactly what was happening when declaring a `struct` with a lifetime, but I really couldn't find much. I'd love to have this expounded upon. For example:

```rust
trait Bazz {
  fn new() -> Self;
}
struct Bar;
impl Bazz for Bar {
  fn new() -> Bar { Bar }
}

struct Foo<'a> {
  bar: Box<Bazz + 'a>
}

impl<'a> Foo<'a> {
  fn new() -> Foo {
    let bar : Box<Bar> = box Bazz::new();
    Foo { bar: bar }
  }
}

fn main() {
  let f = Foo::new();
}
```

There's a lot of syntax going on there and it's not at all clear what it's doing. My impression is that in `main` when we call `Foo::new()` there's an implicit assignment of the "current" lifetime to `'a` which is then passed to `Foo`, but I'm not sure how that works.

If you have a lot of this, you run into Rust's `cannot infer appropriate lifetime` error which is really really hard to debug.