Replace GC with borrowed pointers where possible

__Please do not pull until after release__

I opened this request w.r.t. #16. Although it feels better to remove many of the managed pointers, I'm not 100% convinced it's safe still. All our tests passed, so the driver's functionality is intact, but the compiler may be needlessly finicky in some circumstances and I'm not sure what those are. 

The positives of this change, however, are both freedom from GC changes (and from forcing users to interact with the Gc<T> type when it emerges) and increased use of compile-time correctness checking. Consider the following program based on the current implementation:

```rust
{
  let client = @Client::new();
  let db1 = DB::new(~"db1", client);
  let db2 = DB::new(~"db2", client);
  let _ = client;
}
```

The semantics of this program cannot exist as intended; there is a time at which client has gone out of scope but db1 and db2, which refer to it, are still in scope. Under the current implementation, the lifetime of client is silently extended by the garbage collector to survive until the end of the block, in order to prevent the references held by the database handles from dangling.

The new implementation will throw a compile-time error; because client is being borrowed, it cannot be moved out of. If db1 and db2 are destructed first, the program will compile. This is Rust's best compile-time checking at work; it informs the programmer that the semantics of their program are incorrect and cannot be represented.

I'll continue to play around with it and compare the behavior of the two implementations at compile-time (at runtime they are identical). I'd appreciate any argument for or against the change in implementation as well.

Even if we unanimously agree on this, __it shouldn't be pulled until after release__.