Rearrange source to follow normal Go packaging

The package name is the same name as the repository,
unless the repository will have lots of different packages
in it. This job is small enough to comfortably fit into
one package. Execuatables can go into sub-directories,
especially when they are demos. They will not be built
by "go get", because it works on one package at a time,
and the demos are in package main.

Finally, make the import path fully qualified. This is
a pain with the github "commit then request pull" workflow,
because you'll need to make a second commit to change the
import path in the demo back to your repo. See the closed
pull requests on github.com/huin/mqtt for the more normal
case, where I sent bug fixes in without changing the import
path of anything.
Continued packaging changes

Changes described in the last commit, but checked in here.
Because I'm a loser who can't use git.
Simplify individual, added a test case

This is what tests look like in Go. Note that the
test is inside the genomego package, so it is allowed
to muck around with the internals of the object (in this
case to get rid of randomness, to facilitate testing).

Go does not use this. Instead, the receiver of the method
is chosen like a parameter name, i.e. short, but clear enough
to communicate what's happening. A good choice is always
the first letter of the object, like func (c *Client)Connect().
But in this case, that would be "i", which is "reserved" for
indexes, so a better choice is "me", since an Individual
would normally call itself "me" anyway, if it were alive.

I changed from len(me.genome) to me.size because it is clearer
and less noisy to read. Also, it sets us up for a refactoring
where we decouple the layout of genome from the size (i.e.
a bitfield).
Change to multi-value return for Crossover

Returning an array of kids is pointless here, and makes
garbage, because the [2]*Individual needs to be allocated
and then filled, then it's pointer goes onto the stack. The
current runtime implements multiple returns by pushing
each of them onto the stack, so this implementation creates
no garbage either on exit from Crossover or when the return
values arrive back in the caller (since the caller probably
has registers free to receive them and then work with them,
at least on AMD64. x86 is always out of registers, so it's always
spilling to memory...)

Also, naughty me. Last checkin did not have "go fmt" run on it.
See the difference? :)
Introduce a population type

Use it to hold a lambda that generates random numbers.

Use this to make the system more testable, using random
number generators that always give 0 or 1. Because Mutate
needs random numbers, Individuals now need to remember what
Population they belong to. :(

Note in NewPopulation that for every Population, we create
a new *math/rand.Rand, then capture it in the new closure
assigned to the new population's Rand field. If the Rand
field is overwritten later, then generator becomes unreferenced
and will be GC'd.
Go fmt

Doh.
Fixed ga-example, fixed formatting of Individual

Adding a String() method to a type lets you control
how fmt prints it. If the object does not implement
the Stringer interface, then fmt will print all the
fields, which isn't what we want.

See:
	http://golang.org/src/pkg/fmt/print.go?s=1975:2019#L51
	http://golang.org/src/pkg/fmt/print.go#L702

fmt.Println(*father) didn't work because it dereferenced
father from an *Interface to an Interface, which does not
implement Stringer.