Start work on including real versions of code

The eventual aim is to be able to have runtime control of the
behaviour of our mocks.  Start by refactoring the code that processes
functions and methods so that we will have access to the original
code.  At the moment the original function body is not included - but
we have made the mockFile function nicer ...
Fix return values for _real_XXX

The the return has a name, then we need brackets even if there is only
one return value.  So, always put the brackets in and let goimports
take out the extra ones.
Make mockFile and mockPkg methods

We are about to want access to the FileSet, so stop passing context
into mockFile and mockPkg by changing them to be methods.
Don't assume the receiver has a name

The name isn't required, so we can't rely on it being present.
Load function body

We now use the position information to read the function body text
from the source file.  We don't actually use it yet though, as we
aren't putting enough supporting code in for the generated code to
actually compile.

We need to not skip private functions & methods.  We also need to
include private struct fields.
Start new log for each test run

I keep looking at the wrong test output ...
Make it clearer which output comes from which test

The scenarios log file wasn't recording which test output came from.
This makes it hard to know which output you should be looking at to
fix any particular test.
We weren't coping with shared types

In either the parameters or the return, you can specify multiple names
with a shared type.  This wasn't being handled properly when we
generated the mock versions.
Start outputting original code

We are now outputting most of the original code, but we have broken
things, by exposing some more unhandled cases in exprString.

This also includes fixing the shared_types issue.
Parameters aren't always named

Sometimes a parameter may be unnamed if the original code didn't
actually use it.  We still want to pass it through to the mocking code
though.  In particular, we don't want to generate code that refers to
p-1 instead of p0.
Add some more expressions to exprString

We can now handle type assertions, and indexing expressions.
Switch from goimports to gofmt

Now that we are including all the original code, we don't need to use
goimports to drop extra imports anymore.
Starting adding the framework for runtime control

We can now turn mocks on and off at runtime, at least we could if the
control variable wasn't private.  We do however use this mechanism to
only turn mocking on _after_ the init functions have been run.
Switch fixup back to goimports for now

We need goimports to sort out the imports for mock_XXX.go until we
actually sort out our own imports.
Don't run the test if build fails

If we failed to build/install any of the tools, then we don't want to
run the tests (since we won't be using the modified version).
Switch to runtime mocking

Instead of controlling mocking by choosing which version of a package
we import using rewriting, we now control mocking at runtime.  This
means that in general there is only one version of a package.  It also
means that we have the framework to make decisions about mocking on a
test by test basis.
Add more runtime control of mocking

Individual mocks can now be enabled and diabled at runtime.  So you
have a mock enabled for one test, and disabled for another.
Add a new test for the runtime controls

A test that checks that the runtime controls are working as intended.
Add test for code that uses gomock

If the code we are mocking already uses gomock, then we add a second
import which will stop the code from compiling. This is just a test to
show the problem.
Skip original gomock import

Since we are hardcoding a gomock import, don't include any import of
gomock from the original code.