Try and generate gccgo version from gc version

It would be nice to be able to keep the gccgo version in step with the
gc version.  This is an attempt to automate the necessary changes.  At
the moment only the Go code is being processed, but eventually the C
code will need to be done too (which will probably involve splitting
out the gccgo specific code from that shared with the gc
implementation).
Use the actual ffi types

Get rid of the ffi type proxies, and use the real types.
Make it possible to patch the go files

Rather than require everything to work immediately, allow using
patches to fixup bits of the source that the automatic fixes don't
currently deal with.
Resolve aliases when checking symbol types

When checking the type of a symbol, resolve aliases so that the
underlying actual symbol name is being checked.
fixup a bunch of conversions

Add fixup files that fix up issues that aren't automatically corrected
for yet.
Get bool.go compiling
Ignore the generated .go files

These files are generated from the gc versions, so ignore them.
Expose some more symbols

We need to expose some more symbols to the Go code, which previously
we used functions for.
Remove at_... ffi proxies

Since we're not using the at_... proxies anymore, remove them.
Ignore shared objects
Exported functions must be uppercase

gccgo requires that exported functions must start with an uppercase
letter (i.e. be public functions in Go).
Add base.c for libgopy.ext.so
Ignore gopy binary file
wrap is obsolete, remove it

The wrap tool predates gopy, and has been replaced by it - so remove
it.
Tidy things up a bit

This is tidying up in the sense of pulling more stuff into one place -
i.e. collecting together some of the changes that were previously
only in the source collected together for creating a Ubuntu package
(the actual packaging and Ubuntu specific bits are not included).
Add target to build .go files

For pacakaging purposes a target to build the .go files would be
useful - so that we don't have to include the gc version too.
Add Makefile rules to build tarball

One of the things that we will need as an input to the packaging
process is a tarball of the source files.
Copy the C code from the gc version

This removes all the code from py.c that was originally copied from
utils.c in the gc version - and instead copies utils.c and includes it
into py.c.
clean shouldn't remove files needed by tarball

Anything that is needed for tarball is something that is only
buildable when part of the version control.  So it shouldn't be
removed by clean, otherwise files will be deleted that make is unable
to recreate.
Move VC only files to separate make file

There are some commands that need to be inside VC, and some rules that
will break things if included outside of VC.  So move a bunch of stuff
from the Makefile to a separate file that isn't included in the
tarball.  The Makefile can then -include this file, so it will be
ignored if not available.