Show impl for Weak

Show impl for Weak and tweaked the Show impl for Rc for consistency
Ok, here's the code I used to prove that the `Show` impl could remove the last `Rc`. This code as-written uses `upgrade()`, but if this PR as-written lands, I can ditch the `upgrade()` and start crashing:

```rust
use std::cell::RefCell;
use std::rc::Rc;
use std::fmt;

struct Foo {
    inner: RefCell<Option<Rc<Foo>>>,
    s: String
}

impl Foo {
    fn new(s: String) -> Rc<Foo> {
        let f = Rc::new(Foo { inner: RefCell::new(None), s: s });
        let f_ = f.clone();
        *f.inner.borrow_mut() = Some(f_);
        f
    }
}

impl fmt::Show for Foo {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        drop(self.inner.borrow_mut().take()); // kill the Rc
        // At this point, if the weak value did not use upgrade(), then the value will be
        // dropped and &self will be an invalid reference. As a result, the following line
        // will access deallocated memory (from the String).
        write!(f, r#"Foo \{ s: {} \}"#, self.s.as_slice().escape_default())
    }
}

fn main() {
    let f = Foo::new("test Foo".to_string());
    let f_ = f.downgrade();
    drop(f);
    println!("{}", f_.upgrade());
    println!("{}", f_.upgrade());
}
```