enable requests to get client Certificates

This patch enables Play2.0's https service to request certificates from the client. Requests can be made on resources that need authentication and only on them.

To try it out you can execute in the console

> run -Dhttps.port=8443 -Dhttps.server.clientTrust=noCA

The "https.server.clientTrust=noCA" means that Play2.0 won't refuse certificates just because they were not signed by a well known Certificate Authority (CA). This is very useful when debugging - as getting client certificates signed by CAs would be extremely tedious (and expensive). Furthermore it will also permit implementation of the [WebID protocol](http://webid.info/spec/), which bypasses CA verification for just the reasons cited above . In any case the public key is still verified: that is the TLS layer verifies that the client has the private key corresponding to the public key sent in the certificate to the Play instance - this is enough for most use cases.

The patch implements the following method in ```RequestHeader```

```scala
trait RequestHeader  {
   //...
    def certs: Promise[Seq[Certificate]]
  //...
}
```
The certs request returns a Promise of a certificate chain.  To test this out create yourself the following controller:

```scala
package controllers

import play.api._
import play.api.mvc._
import play.api.libs.concurrent._

object Application extends Controller {

  def index = Action { req =>
    Async {
      //timeouts should be set as transport specific options as explained in Netty's ChannelFuture
      req.certs.extend1{  
        case Redeemed(cert) => Ok("your cert is: \n\n "+cert )
        case Thrown(e) => InternalServerError("received error: \n"+e )
      } 
    } 
  } 
}
```

If you get yourself a certificate at https://my-profile.eu/ using the [Get a WebID](https://my-profile.eu/profile.php ) service, you can then point the browser you used there - and which should now contain a certificate - to authenticate on https://localhost:8443/ - ie the local server you started above.

You will notice that other resources on your server are still accessible without you being required to provide TLS client certificates. This is because the server does not request a cert up front - as many TLS servers do - but only requests a cert when the programmer calls the `req.certs` method: this forces a TLS renegotiation (if the certificate it not available). 

   Note: There were some bugs in TLS renegotiation a few years ago that have since been fixed. This is explained in detail in the [Java™ Secure Socket Extension (JSSE) Reference Guide - Transport Layer Security (TLS) Renegotiation Issue chapter](http://docs.oracle.com/javase/7/docs/technotes/guides/security/jsse/JSSERefGuide.html#tlsRenegotiation), and you may want to set some other properties as described there to tune the security of your server.

I did not add a test suite as I could not find a server side test suite in Play - perhaps I just did not look carefully enough. Also there is no documentation yet - other than this note.

Note also that this builds on [pull request 339](https://github.com/playframework/Play20/pull/339), which enables TLS in dev mode, which is clearly very useful when trying to develop secure applications.

As a matter of interest, writing this is particularly easy in Play 2.0 because of Netty, and the support for Promises based
on Netty async IO. With other servers this would be a lot more difficult, and a lot less efficient too.

[see also ticket 215: TLS-HTTPS support in Play 2.0](https://play.lighthouseapp.com/projects/82401-play-20/tickets/215-tls-https-support-in-play-20)