Remaking the in-game menu using libRocket

This change removes the old Guichan-based menu and begins the addition of a new libRocket-based menu. Corresponding RML and RCSS files have been added, and the Home Menu has been changed to initialize a pane using a Rocket context.

The MenuShell class has been changed to hold the Rocket context for the menu state, as well as the menu frame (sidebar and background). This class will also eventually handle responses to list events. The MenuShell now only holds pointers to the RocketContext and ElementDocument, and these are reference counted by the Rocket library and deleted accordingly. The copy constructor and destructor of MenuShell increment and decrement references respectively. As a result, MenuShell instantiation (i.e. from MainMenu and TileEngine) no longer leaks memory.

GraphicsUtil has been changed to provide a factory method for Rocket contexts.

The EdenRocketBindings class was added to create and manage listeners created for a document. MainMenu::bindAction has been merged into this class since those binding helpers will be useful for every Rocket UI in the game.

A view model was added to expose the Player Data to the HomePane in a Rocket DataGrid. The result is that the character summary remains dynamically populated. An ImageFormatter was also added to wrap image paths in <img> tags.

This commit unfortunately marks a loss in functionality, as the menu prototype needs to be recreated from the ground up. However, implementation of a new prototype should be much easier, as the menu code is no longer bloated with widget creation and management.
Refactoring common menu code

Reintroducing the MenuState concept for the menu to hold common menu
state code (handling the rendering and action parsing for Rocket, for
instance).

The MenuShell now sends the currently active menu state events when a
sidebar option is clicked. The next commit will bring back other menus.

Also fixed a bug where the menu shell would move in front of the active
pane when clicked, since the background of the shell was not
transparent. To fix this, I split the menu shell into a background
document and a shell widget document.
Adding Data Menu, fixing some bugs

Added back the data menu along with its previous functionality. At this
point, the menu is roughly back to where it was before in terms of
functionality. The Guichan version of the menu also had mockups of the
Item and Equip menus, so those will need to be added back in as soon as
possible.

While doing this, also fixed a nasty segfault that resulted from the
EdenRocketBindings. Basically, when the EdenRocketBindings goes out of
scope, it deletes the listeners that it allocated. But since they're
still attached, there is a segfault when libRocket tries to detach the
listeners and run their OnDetach functions. To ensure that this won't
happen again, the RocketListener detaches itself on destruction,
ensuring that it will never be attached after it is destroyed.

Added a deactivate method for the ExecutionStack to call whenever a
state is removed from the top of the stack (either by being popped or
by another state being pushed on top of it). Currently, this is used by
the menu states to hide windows from states below the current active
state.

Added a check in ImageFormatter to ensure that null or empty strings
don't result in img tags being created.

Made MenuShell a pointer managed by MenuState… I was pretty happy about
the way I implemented this before, but having get copied across menu
panes meant that each copy had its own menu state reference, and so
each instance of the menu shell had a different "active state". This
meant that sidebar clicks would always go to the wrong state. Now, a
single MenuShell instance is shared by all menu states, and so there
are no longer any synchronization issues.

Added code to PlayerData to properly clear out old data before a new
save game is loaded in.
Converting Dialogue box to libRocket

The dialogue controller now uses libRocket! This allows for altering
the style of the dialogue box using CSS instead of making code changes,
and removes the need to programmatically determine the proper
coordinates for vertical and horizontal centering.

This change pulls some of the common MenuState/MainMenu code into
GameState. Where GameState used to manage a Guichan widget container,
it now manages a libRocket context instead. Calls to step or draw the
Guichan GUI have also been replaced with equivalent calls to
libRocket's Update and Render functions.

All GameState subclasses now provide a name to uniquely identify their
Rocket contexts.

The Menu Shell no longer creates a Rocket context since the GameState
will always create one (nearly every game state has a GUI, after all).
The MenuShell will increment and decrement the context's reference
count for proper memory management, however, since the menu shell can
be owned by multiple states.

The next commit will remove the Guichan library and EDWT classes from
the source tree entirely.
Converting DebugConsoleWindow to RML, removing EDWT

Removing the ED Widget Toolkit, created as an extension to the Guichan
widgets. All the extra stuff that was in EDWT is taken care of easily
by Rocket's event handling and by RCSS (such as text centering). This
reduces code bloat tremendously.

To ensure that functionality isn't lost, the DebugConsoleWindow was
rewritten to use an RML document like the rest of the GUI elements.
Some of the input in TileEngine was filtered to ensure that it won't
conflict with the debug console when that window is visible.

Fixing RocketSDLInputMapping to send text input commands in addition to
regular key press events, so that text input boxes would work correctly.
Removing Guichan from the source tree entirely.