Refactor milestone 2
Restructuring of many core classes

MojamApplet renamed to AppletLauncher (still doesn't work)

Added new Launcher interface to define communication from
CatacombSnatch back to the Launcher specific code.

StandaloneLauncher and AppletLauncher now implement Launcher

Refactored StandaloneLauncher, CatacombSnatch and GameMenus
- Much of the orchestrating has been moved from GameMenus
  into CatacombSnatch. It now owns global instances of:

  -- Launcher, LocalGameInput, GameSound, GameLogic and GameMenus
  -- GameInformation (new class, see below)

  It also defines the behaviour for:

  -- Starting the game loop, and the render & logic callbacks
     (including managing music and rendering the mouse pointer)
  -- Starting a new game, stopping a running game
  -- Exiting

- GameMenus is now much simpler
  -- Deals with stack functionality (delegated to a Deque) of menus
  -- Dispatches tick()s to the current menu
  -- Also, since GameView was refactored (see below), its menu rendering
     responsibility was removed, and now GameMenus dispatches render()s
     to the current menu and sets up the background depending on whether
     a game is currently in progress

Refactored rendering (GameView, SimpleGameView,
CatacombSnatchCanvas, ScreenRenderer, Level, Entity and subclasses,
Notifications)
- CatacombSnatchCanvas now:
  -- keeps track of the graphics scaling
  -- no longer knows which GameView is is rendering
     (ScreenRenderer interface also updated in kind)

- GameView:
  -- now defines viewport boundary getters
  -- no longer has constant SCALE (equivalent is now in CatacombSnatch)
  -- now defines getPlayer()/setPlayer()
  -- renderView() now just takes a single Screen argument

- SimpleGameView:
  -- No longer keeps track of a ScreenRenderer or calls
     ScreenRenderer#render(), this is now done in the render callback
     defined in CatacombSnatch

  -- No longer renders the mouse pointer, this is now donw in the
     render callback defined in CatacombSnatch (TODO? Note that
     it still renders the FPS, which means that it only appears
     when in the game, not while using menus)

- Level is now aware of the GameView it is being rendered to
  and uses the GameView's new viewport bounds to decide which
  area of the map to render

- Entity and all its subclasses are aware of the GameView they
  are being rendered to, which also gives awareness of the Player
  associated with the GameView allowing many previous checks against
  the local client's team to no longer be necessary. These checks
  can just use the GameView's player's team.
  -- Notably Building#renderMarker() uses this to know whether it
     should render a marker on a particular GameView

- Similarly Notifications knows which GameView it is being rendered
  to, and in addition to other refactors (see below) it can choose
  whether or not to render a note to the GameView (this means these
  sorts of checks are not required when calling Notifications.add()
  when you only want one particular player to see a Notification).

Notifications changed so that it records the source of the notification
(the source character and team) and also the intended recipients (using
an enum which currently allows CHARACTER, TEAM, OPPOSING_TEAMS, ALL)

Changed the way that the currently selected GameCharacter is
stored
- The overall selected character is now only stored in Options
- Options was changed to store the GameCharacter enum name rather
  than the ID, and the GameCharacter can be set and retrieved with
  convenience methods Options.getCharacter() and Options.setCharacter()

- The GameCharacter enum no longer has a member called None, the code
  has been changed to use null instead (makes the code slightly neater)

GameInformation keeps track of the selected game type of the upcoming
and currently running game (eg SINGLE_PLAYER, SYNCHED_NETWORK, ...)

Many classes changed to import static the basic global game objects
(like CatacombSnatch's GameMenus, GameSound, GameInformation, etc)

Minor changes to Player:
- No longer keeps track of the GameLogic, it didn't use it, and
  now there's a global GameLogic statically available on CatacombSnatch

- Can now set initial facing via the constructor
- Now defines a getter for its associated GameInput
- No longer needs to check on the "local team" (which has been removed)

GameLogic, NoGameLogic, and LocalGameLogic
- No longer keep track of whether the mouse is active, this is now
  done by GameInput

- No longer has knowledge of a local player
- Now keeps players in a List rather than an array
- Now defines new methods: isPlaying(), getGame(), renderViews()

- The tick() method no longer receives a GameInput argument, it
  isn't needed any more since each Player keeps track of their
  associated GameInput. It also iterates through the list of players
  to each player to deal with the pause key (TODO should probably be
  moved into Player#tick() now I think about it)

- The LocalGameInput constructor now just takes a single GameInformation
  as its argument and constructs the Level and Players from its contents

Due to bugs introduced by changing the signature of Entity#render(),
which is heavily overriden by subclasses, I went through most classes
to ensure that every overriden method is annotated with @Override (this
would have caused compile errors to appear instead of more difficult
to spot or understand bugs -- like all animations using floor tile
graphics
instead of their proper graphics!)

Building and subclasses:
- Changed the way highlighting of Buildings works so that instead of
  using a boolean to track if it is highlighted, it uses a Set to
  keep track of which Players have it highlighted (this allows
  renderMarker() to know, in combination with the GameView, whether
  or not the building should be highlighted in the currently rendered
  GameView)

- No longer needs to check on the "local team" (which has been removed)

SpikeTrap, DropTrap:
- Removed unused methods isBuildable() and isHighlightable() (I think
  these came from a time where traps were floor tiles, if they become
  so again, then the interface will prod them to be readded)

LocalGameInput:
- Now keep track of whether the mouse is currently active
- Now keeps track of rendering scale (like ScreenRenderer) so
  that mouse position can be scaled back to Screen coordinates

SimpleGameLogic now implements Runnable and start() was changed to
run(); this makes it convenient for running in a new Thread.