Convert all api.State.Call() sites to pass in a Version=0 argument.
FacadeVersions starts to track what versions of the various API facades that we know about.
Implement api.State.BestFacadeVersion.

Use the cached 'best' version for all of the API Facades that we know about, and match
that against the versions that Login returns for us.
start working on changing all the call sites to actually select the best API version.

However, there is definitely a repeating pattern which I'd like to clean up, so I'll side track to that
before finishing this work.
Start working on a base.FacadeCaller which lots of things end up using.

I'm not settled on it. I *like* that they all end up with a simple .APICall to call,
and I like that they all end up easily exporting a BestVersion function that they can use.
I don't like that they export APICall and RawCaller.
I'm also not sure that FacadeCaller should be an interface rather than just being the
concrete type that everything embeds.
consider BestAPIVersioner instead of exposing all of FacadeCaller.
Merge branch 'api-versioning-4-login-describes' into api-versioning-5-state-call-takes-version

Resolve Conflicts:
	state/api/client.go
	state/api/watcher/watcher_test.go

This brings in a newer trunk, and we resolve conflicts against it.
Possible renaming of interfaces.

Get rid of the BestAPIVersioner as an interface.

Change the root api.State.Call into api.State.APICall and change the facade
wrapper to use CallFacade. The latter will be renamed to FacadeCall in the
next patch.
CallFacade doesn't fit very well tone wise, and doesn't follow the FooCall
pattern.
Rename all of CallFacade to FacadeCall.
Switch from isa to hasa as the relationship between the api facades and their facade caller.

This also changes some of the call sites so that 'life' helpers are gone, since they are replaced with
something pretty concise by itself, but I didn't change all of them. I might go back, but I think I
prefer the inline form.
Rename the internal 'caller' attribute into 'facade' attribute.

This hopefully will make it clearer what is actually going on. No guarantees, though.
Change common.EnvironWatcher to use the FacadeCaller interface.
Track down the last few that weren't using FacadeCaller.

The Watcher code itself can't use FacadeCaller, because it wants to pass an Id.
We could change the FacadeCaller code, but I don't think its worth it.
It should keep it easier to reason about how the code is flowing that all FacadeCall
are not tied to an id.

This also gets us away from the proliferation of func call() methods on every
client-side Facade implementation.
Turn the 3 client-facing facades into base.ClientFacade implementations.

Client is still special because it needs the extra attributes to lookup things like debuglog, etc.
Merge branch 'master' into api-versioning-5-state-call-takes-version

Ran into lots of conflicts with the changes to how 'tag' is used and
changes that introduced a common.Watch method. They are nice
improvements, but did have to resolve a bunch of conflicts.

The only bit remaining that is broken is that usermanager was exposing
'call' as a top level variable so that it could be overriden during
testing. We can do the same thing by replacing the FacadeCaller which
will also help us avoid global state. But that still needs to be done.

Conflicts:
	state/api/client.go
	state/api/deployer/deployer.go
	state/api/deployer/unit.go
	state/api/export_test.go
	state/api/firewaller/firewaller.go
	state/api/firewaller/service.go
	state/api/firewaller/unit.go
	state/api/machiner/machine.go
	state/api/machiner/machiner.go
	state/api/provisioner/machine.go
	state/api/uniter/service.go
	state/api/uniter/unit.go
	state/api/usermanager/client.go
Implement a PatchResponses that lets us do lots of nice direct testing of how the client code handles various server responses.
Added first outline of the Juju API Design Specification document.
Merge master, resolve all of the conflicts from changing client calls while names.Tag changes were concurrently happening.
get rid of api.State.Call() in favor of api.State.APICall.

The former was just one more 'Call' function that permeates our code and makes it
hard to know what thing is actually going on. (we had some cases where Call called Call
about 4 layers deep.)
reset all of these files back to what is in 'master'.
This is an attempt to split this patch into parts that are mechanical, and parts that should be 'interesting'.

Most of these changes are just mechanical, so they'll all end up in the followup branch.