Ensure authenticate never re-auths.

Other API functions will support re-auth as a matter of course.
If an auth token expires, we need to re-authenticate to acquire a new
token.  If re-authentication were itself to attempt re-auth, we
would end up in an endless loop.

If after authenticating gophercloud receives a 401 Unauthorized
response, then we must assume that the provided credentials are
incorrect.
Add elementary support for reauth.

Preemptively attempting to reauthenticate before a token expires is
fraught with dangers.  Everything from buggy API implementations to
natural lack of determinism when an API races against a server can cause
opportunities to reauth to be missed.  The recommended solution is to
just detect when a 401 Unauthorized error happens, and attempt to handle
it with a new attempt at reauthentication.

This commit does not implement the full logic to do this just yet.
However, the groundwork seems to be in place, if my unit tests are any
indication.  Here's how I'd _like_ to use it:

Let's focus on ListServers.  We'd end up rewriting this function like
so:

// See the CloudServersProvider interface for details.
func (gcp *genericServersProvider) ListServers() ([]Server, error) {
  var ss []Server

  url := gcp.endpoint + "/servers"
  errOuter := gcp.context.WithReauth(func() error {  // NEW CODE
    errInner := perigee.Get(url, perigee.Options{
      CustomClient: gcp.context.httpClient,
      Results:      &struct{ Servers *[]Server }{&ss},
      MoreHeaders: map[string]string{
        "X-Auth-Token": gcp.access.AuthToken(),
      },
    })
    return errInner
  })                                                // NEW CODE
  return ss, errOuter
}

Note how small the change to the existing code is: two lines of code.

Context.WithReauth() works by invoking the supplied function,
optimistically hoping that it'd succeed (e.g., that error is nil).  If
so, we bee-line the results back to the ListServers implementation,
where it returns its results in ss and a nil value for errOuter.

If it does fail with an error other than a 401 result, ss is undefined,
and the error will propegate back out to errOuter, where again it'll be
returned to the caller.

If the error is a 401 error, however, we invoke the configured
reauthentication handler for the given context.  This code is
responsible for attempting the reauthentication process.  If an error
occurs in this handler, it too will propegate out to errOuter.

If everything succeeds up to this point, however, the function defined
above is called a second time.  Assuming it succeeds, it will overwrite
the desired result (ss in our case) with a valid value, and return a nil
error.  This will, as above, produce the desired outcome and all is
well.

If it fails a second time, however, you're on your own.  Even if the 2nd
failure is another 401 result, that error will propegate out to
errOuter, where it'll be returned to the caller.

Known problems with the code as it stands:

1) Procedure passed to WithReauth() is expected to return an
interface{}, being the desired, unmarshalled object from a web request
against an API.  But, I had forgotten that I could use a free variable
(as I do in the example above) and avoid having to return it explicitly.
I'll need to remove this result slot, saving code and complexity.

2) I *may* need to pass an AccessProvider as part of the WithReauth()
call, so that the reauth handler has something to work with.  Otherwise,
I'll need to define an interface for all xyzProvider entities to recover
the AccessProvider it uses.  I'm not entirely sure if this breaks
encapsulation or not.

Otherwise, the logic is 99.44% finished, and unit tests all pass with
this commit.  Acceptance tests aren't affected, as no production logic
has yet been changed to use this mechanism.
Simplify WithReauth() and its dependency workflow.

This change also threads the desired AccessProvider to the reauth
handler, so the reauth handler doesn't have to fish it out through some
hard to maintain back-channel.
Add early acceptance test for reauthentication.
Tie AccessProvider back to service Provider.

To issue a revokation request, I needed to know the Identity API
endpoint.  This endpoint exists in the Provider used to create the
AccessProvider.  This change threads a link back to the Provider.
Convert ListImages to use reauth.

This commit does not work -- acceptance test 08-... is broken.
Remove debugging infrastructure.

Bug was found, and things seems to work.  In summary, a comparison for
err != nil was performed where I intended err == nil instead.
Merge pull request #46 from rackspace/reauth

Implement Reauth capability