Create a Stoppable pattern for objects with associated go-routines.

There is a common pattern of objects having associated go routines
that need to be stopped in a synchronized way when the object is
destroyed. Stoppable represents a standard pattern for dealing with
this, along with limited code support.

Ojbects that wish to be Stoppable are expected to to start their
routine in their New method, and for that routine to exit when Stop is
called. Their go routines should follow the following pattern, but add
addition channels to watch as needed, and additional shutdown code to
either their Stop methods, or to the StopChan handler code.

func (b *Stoppable) Handler() {
  for {
    select {
      case <-b.StopChan:
        b.StopChan <- true
        return
    }
  }
}

There is a Base type to compose which creates the StopChan member, and
creates the default Stop routine. Objects which wish to compose with
it should either add "go Handler()" to start their own routines. A
placeholder routine is composed in, if not overridden.

To avoid deadlocks, some objects may need to replace Stop with a
version that does preliminary shutdown code. These objects should
still call "stoppable.Base.Stop()".

Examples of different usage can be found in stoppable_test.
Adjust Stoppable objects to use stoppable (interface and Base).

Go through all of the types that were using the Stoppable pattern, and
adjust them to conform to the Stoppable interface and pattern as well
as to start using stoppable.Base.

This also involved cleaning up a lot of type initialization code.

No logical changes are made other than no longer handle errors when
stopping. Since we didn't handle those errors properly anyway (and
usually can't) this makes sense. If a critical error happens during a
Stop, we should panic instead.