Fix `prepend_scheme_if_needed` for $HOST:$PORT

`prepend_scheme_if_needed` is used for the proxy, but failed to do so properly for `host:port`.

This PR addresses the first occasion in the docs I've stumbled upon, fixes the implementation and adds tests.

(This is derived from https://github.com/kennethreitz/requests/pull/2219.)

If this seems OK, the documentation at https://github.com/kennethreitz/requests/blame/master/docs/api.rst#L238-249 needs to get removed/addressed also.


So here's the thing, I can't think of any proxies that require a path or for which `hostname:port/` is normal practice. Everything about how we operate currently is perfectly fine for the 90% use case and we've had this support for over a year without a complaint. `urlparse` is far from perfect, I agree. Your documentation fix is also a good one. I am, however, against the change you've made to `prepend_scheme_if_needed`. It's entirely unnecessary. What we had previously is a very robust solution which also handles `//localhost:80` and other _valid_ variants on a URI. This would have us give up that solution for something that (in this case) produces `http:////localhost:80`. This would cause issues for a user as well.


My objection to this functional change is simpler than @sigmavirus24's. URLs are not strings, and treating them like strings is how mistakes get made. I think the correct approach would be to try to use `urllib3`'s URL utilities for this.


Thanks for your feedback.

@Lukasa 
I've initially used urllib3's `Url` (https://github.com/blueyed/requests/commit/1bcc46e50661a68e08723571ac42d8069d2b4063 - was amended), but then noticed that I would have to handle `auth` explicitly, in the same way it gets done in PrepareRequest (IIRC), and "simplified" it.

If urllib3 had a method to "urlunparse" (proposed in https://github.com/shazow/urllib3/pull/394), this could be used here. But then it seems that urllib3 would also fail for `//localhost:80`, because my simplification was inspired by its scheme detection: https://github.com/shazow/urllib3/blob/master/urllib3/util/url.py#L111-L113:

```
util.Url("//localhost:80")
Url(scheme='//localhost:80', auth=None, host=None, port=None, path=None, query=None, fragment=None)
```

For now, I propose to only change the documentation to state that the default scheme is "http".
What about the documentation at https://github.com/kennethreitz/requests/blame/master/docs/api.rst#L238-249 ?

As for the approach to simplify it, it could get expanded to also check for `//` at the beginning of url.

Given that the function is meant to only prepend a scheme, it should be enough to detect if a scheme exists already, and that does not require to parse all of the url in the end.

Side note: about the validity/usefulness of `//localhost`: would/could this be interpreted to be `https://localhost` for `https_proxy` and `http://localhost` for `http_proxy`? (relative to the protocol that is being accessed).
([RFC](http://tools.ietf.org/html/rfc3986#page-26)).


Let's do some blue-sky thinking for a moment.

Is it possible for us to build a truly correct URL praser/unparser that assumes HTTP? I believe that it is, and I think we should do that first, and then switch to using it consistently throughout requests.


@Lukasa if you build a good parser for RFC 3986 then it will. [rfc3986](/sigmavirus24/rfc3986) for example parses the examples here with ease:

``` pycon
>>> from rfc3986 import uri_reference
>>> uri_reference('//localhost:3182')
URIReference(scheme=None, authority=u'localhost:3182', path=None, query=None, fragment=None)
>>> uri_reference('//localhost:3182/')
URIReference(scheme=None, authority=u'localhost:3182', path=u'/', query=None, fragment=None)
>>> uri_reference('//localhost.localdomain:3182/')
URIReference(scheme=None, authority=u'localhost.localdomain:3182', path=u'/', query=None, fragment=None)
```

The only hiccup is that RFC 3986 does not define every URI to have the structure `scheme://authority{/path}{?query}{#fragment}`. A valid URI, for example is: `mailto:user@domain.com:port` and in this case `mailto` is the scheme, so the following happens:

``` pycon
>>> uri_reference('localhost.localdomain:3182')
URIReference(scheme=u'localhost.localdomain', authority=None, path=u'3182', query=None, fragment=None)
```

Sadly this isn't a bug and attempting to special case it will lead only to trouble in all likelihood.