Test for stroke round rect precision

Turns out bug was in my code, but this was useful.
Initialize properly to prevent crash when going back to menu
Fix boxes around labels
Fix bug with touch handling

When testing PointerMouseTouch, it wasn't possible to enter another test. So always decrement that active touch count.
Back button for pointermousetouch
Get tests compiling again
Make those box labels big
Fixed the Javadoc for Layer's depth() and setDepth() methods.
Improvements to update and paint fluency.

1. We properly calculate alpha as the fraction of time past the "ideal" time at
which the last update took place.

2. We account for update() calls that take non-trivial amounts of time (which
causes alpha to be even larger that we would have otherwise computed).

3. We use System.nanoTime() which is less wacky than
System.currentTimeMillis().
Improved docs for paint(alpha).
Use SBT 0.12.2.
Revamped Game interface, added Game.Default. Added PlayN.tick().

TL;DR: change "implements Game" to "extends Game.Default", delete your
updateRate() implementation and instead pass that value to Game.Default's
constructor.

Details:

- PlayN.tick() returns the number of ms that have elapsed since game startup
  (as an int, which is safe to use in JavaScript or otherwise).

- Game.update/paint/updateRate went away (sort of) to be replaced by Game.tick.
  A game that wants to handle updating and painting via some custom mechanism
  now just implements Game.tick and does their own simulation updating and
  scene graph interoplation.

  "Normal" games now extend Game.Default instead of implementing Game.
  Game.Default provides update(int delta) (which eliminates a pointless and
  problematic use of floats) and paint(float alpha). Game.updateRate goes away
  and is passed to Game.Default's constructor. You can no longer change your
  game's update rate on the fly, which was wacky.

  Game.Default implements the update/paint approach that was previously (sort
  of) mandated for all games. There is no longer the "updateRate = 0" hackery
  because games that want to do custom things just override tick() and don't
  have to second guess what the platform is doing.

  Game.Default.update differs from the old Game.update in that updates will be
  coalesced if the game is running slowly. See Game.Default.update's javadocs
  for details.

  Game.Default.paint differs from the old Game.paint in that alpha can be
  greater than one if your game is running slowly (but this is really the right
  thing to do and your code will probably just do the right thing if you're
  doing interpolation math normally).

  Game.Default's calculation of the 'alpha' value passed to paint is more
  accurate and should result in smoother display in games that actually use it
  to interpolate between simulation updates.
Added a Clock abstraction.

This saves having to do this same math in a zillion places throughout
libraries.
Added code to track and report last paint delta.

This is useful for animation APIs that just want a delta, or that want to
accumulate time. It saves them from having to initialize a start time and then
subtract the current time from that start time.
Enforce updateRate > 0 via an assert.
Nixed some vestige.
Provide the paint alpha in Clock as well.

Sometimes you need alpha adjusted frame time, sometimes you need dt, and
sometimes you just need alpha. You need it, Clock's got it!