DST coercions and DST fields in structs

The commits are not quite stand alone, I should probably squash them together before landing. In particular if you review the individual commits, then you'll see some scrappy stuff that gets fixed in later commits. But reading the commits in order might be easier to get an overall idea of what is going on.

The first commit includes putting back time zone into our time library - @pcwalton removed that as part of his de-~str'ing, but I had already converted it to use StrBuf, so we may as well leave it in. Update: no longer, this is removed in a later commit.
In an example like this, instead of using the `'static` lifetime in tandem with some non-static lifetime, I would prefer if the code were written in terms of two lifetime parameters `'a, 'b` that have an ordering imposed on them, e.g. via an unused parameter `_p: Option<&'a &'b ()>`.

At least for me, that makes it clearer that the thing being tested is the lifetime relationships themselves, and that there is nothing special about `'static` with respect to the test case.

Also, the comment at the top is misleading.  At least, as far as I can tell, you *can* change the lifetime, as long as you are assigning into a compatible location (namely a location with a lifetime that is smaller than the original lifetime).

Here is an example of some code that currently compiles (and I believe is correct in doing so) but is definitely changing the lifetime from `'b` to `'a` at the same time that it turns a thin-pointer into a fat-pointer:
```rust
struct Fat<type T> {
    _ptr: T
}

struct Foo;
trait Bar {}
impl Bar for Foo {}

pub fn main() {
    fn foo1<'a,'b>(f3: &mut &'a Fat<[int]>,
                   f2: &'b Fat<[int, ..3]>,
                   _p: Option<&'a &'b ()>) {
        let tmp : &'a Fat<[int]> = f2;
        *f3 = tmp;
    }

    // With a vec of ints.
    let f1 = Fat { _ptr: [1, 2, 3] };
    let f2: &Fat<[int, ..3]> = &f1;
    let mut f3: &Fat<[int]> = f2;
    foo1(&mut f3, f2, None);

    fn foo2<'a,'b>(f3: &mut &'a Fat<Bar>,
                   f2: &'b Fat<Foo>,
                   _p: Option<&'a &'b ()>) {
        let tmp : &'a Fat<Bar> = f2;
        *f3 = tmp;
    }
    // With a trait.
    let f1 = Fat { _ptr: Foo };
    let f2: &Fat<Foo> = &f1; //~ ERROR `f1` does not live long enough
    let mut f3: &Fat<Bar> = f2;
    foo2(&mut f3, f2, None);
}
```