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.
Fix libhttp dependency so examples don't *always* rebuild.
Remove by-value self bug workaround.

(It appears to now be fixed upstream.)
Determine port based on scheme and allow arbitrary ports.
SSL support implemented

utilizes rust-ssl or rust-nss to optionally provide SSL services.