Simplify ext.c code a bit

The way that g0_main was resetting the state on entry meant that the
only way we could get in with something to do was to jump in using
setcontext - this made the code more complicated than necessary.
Refactor things so that we can get g0_main to do something useful on
the first time through if we want.

Also add a few more comments here and there, and tidy a few things up
a bit.
Start adding support for creating executables

Start adding support for executables that will be able to load the Go
extension modules that the gopy command creates.  Without this support
you can either have Go around Python (regular gc goPy), or Python
around Go (i.e. Go extension modules), but not both at the same time.
Git rid of the cgocallback failure function

We don't need the failure function that we introduced to raise an
exception when calling into Go from another thread now that we send
requests into the ctxtDispatcher goroutine.  Remove all the support
for the failure function that we added, since we don't need it
anymore.
Don't swap signal handlers inside Go runtime

Since ctxtHandler always runs inside the Go runtime, there is no point
in swapping the signal handlers on entry/exit as we will be swapping
between the same set of handlers.
Don't change context when not needed

If _init_go is called when running in a Go executable, we need to
handle the call slightly differently.  Basically, we just need to drop
out of syscall to call do_inits - instead of calling run_on_g.
Ignore generated files
Parse pkgpath from .go_export

Now that gccgo is producing pkgpath statements instead of prefix
statements, we need to handle the new statement to get the symbol
names correct.
Add some more examples

These are more examples that exercise some of the more recent
functionality (executables and threading primarily).
Update man page