Game state machine

- Added enum EngineGameState.
- Added property Engine.GameState (thread-safe).
- Added property IsReady.
- Added sanity check helpers and used them in all public entry points of
Engine.
- Made Engine implement IDisposable and cleaned stop code.
Simplified core model API

+ Added Table.GetEnum()
+ Added Enums.EnumUtils.ParseEnum()
+ Public methods Table.GetXXX() now protected.
+ Added Task.CorrectState and TaskCorrectness.
Thread-safe and asynchronous core (part 1)

Part one of a huge refactor that includes:
+ Protection of all calls to Lua against thread concurrency.
+ Added class LuaExecutionQueue for async Lua job scheduling.
+ Moved most utilities to be extension methods.
+ Simplification of model API.

Todo/Known issues
+ Buffer UI thread jobs (RaisePropertyChanged...) while the
LuaExecutionQueue is busy with big jobs.
+ Refactor thread-safety inside a SafeLua state that can be passed
around to other objects.
+ Refactor serialization out of Engine (other classes) and implement
thread-safety.
Thread-safe and asynchronous core (part 2)

Part two of the big refactor. This commit includes:
+ Dynamic management of events to the UI thread thanks to a
Dispatcher-like custom system (Utils.Threading.JobQueue).
+ Added Utils.SafeLua, a thread-safe utility wrapper around a Lua state.
This is the only lua context that can be used outside of Engine and
WIGInternalImpl.
+ Non critical events are buffered when the Engine's LuaExecutionQueue
is busy, in order to avoid a potential UI hangup when user code calls
lua-backed properties of Table.
+ Serialization code now thread-safe (remains to be tested) and
separated from the engine code.
+ Added sub-namespaces for clearer class presentation to the user. (WIP)

Todo/Known issues ("...In the next episode...") :
- Write async helpers in Engine for asynchronous calling of game-related
operations
- Cleaner architecture of loader classes (Formats) using interfaces.
- Document the source code thoroughly.
Thread-safe and asynchronous core (part 3)

Part three of the big refactor. This commit includes:
+ Abstraction of platform-specific data and operations (IPlatformHelper)
that are used by Engine.
+ Refactor of the loading layer using interfaces (ICartridgeLoader).
+ Cleaner architecture of the core: model classes are in root, engine
classes in the Engines namespace. (Updated the WP7 and main Core
projects)
+ Added WherigoHelper as an entry point for client use-cases.
+ Added UI feeback from Engine about the business of the Lua execution
queue and the UI dispatch pump. (See bindable property Engine.IsBusy).
+ Made Cartridge extend Table.
+ Documented parts of the code.

Known issues / Todo:
- Write standard IPlatformHelper implementations for other projects:
iOS, Android.
- Write standard init-and-start methods in WherigoHelper (sync and
async).
- Potential concurrency problems in Cartridge. (Write thread-safety.)
- Thourough documentation.
Fixes aftermath of merging.