Fix up comparison running script for rustpkg changes.
Tiny meaningless fixes for the comparison runner.
Make HTTP client example more flexible.
Fix examples bin/client dependency.
Improve efficiency in buffer allocations.
Add a link name for codegen/main.rs.
Update http link metadata.
Revert rustpkg changes from #36/#40 for now.

Why? rustpkg is ignoring -O which is killing performance.
Update comparisons data (we're doing better!).
Update to rust-master.

std::rt::io has been renamed to std::io;
Merge pull request #43 from am0d/rust-master

Update to rust-master.
Update README.rst

`make` alone doesn't build the examples.
Merge pull request #44 from derekchiang/patch-1

Update README.rst
Fix build related to task::spawn_* functions deletion.
Merge pull request #45 from KokaKiwi/master

Fix build related to task::spawn_* functions deletion.
Update upstream iterator method names.
Update upstream iterator method names in codegen.
Updates for upstream closure reform.
Stop using std::cell (no longer necessary).
Remove the commented-out SimpleServer.

With the closure reform, it's still not possible to manage this through
a closure; a static closure, which would have the type ``'static
|&Request, &mut ResponseWriter|``, is the only type that would be
clonable, and they're not so, nor do they make much sense as a concept.

The alternative (which *does* work) is a reference to a bare function,
``&'static (fn(&Request, &mut ResponseWriter))``. But by the time you're
doing that, there doesn't seem much benefit in SimpleServer's existence
at all. Here's what is currently possible::

    #[deriving(Clone)]
    struct MyServer;

    impl Server for MyServer {
        fn get_config(&self) -> Config {
            Config {
                bind_address: SocketAddr {
                    ip: Ipv4Addr(127, 0, 0, 1),
                    port: 8001,
                }
            }
        }

        fn handle_request(&self, r: &Request, w: &mut ResponseWriter) {
            ...
        }
    }

    fn main() {
        MyServer.serve_forever();
    }

And here's what it would look like with the construct that could work
but which I'm removing rather than fixing::

    fn main() {
        fn handler(r: &Request, w: &mut ResponseWriter) {
            ...
        }

        serve_forever(
            SocketAddress {
                ip: Ipv4Addr(127, 0, 0, 1),
                port: 8001,
            },
            &handler,
        );
    }

Yes, it's shorter, but is that really necessary? This is, after all,
intended as a fairly low-level thing.