Reflect Refactor complete

[Geoff Evans]

Principal work integrating Reflect into the asset pipeline is complete and merged into master (reflect_refactor branches in all modules are deleted).  Inspect, SceneGraph, and Editor are removed from the build scripts as they still need some work, but they were broken before wrt the engine, so haven't lost much per se.  I am actively working on bringing them back online now, but there was no reason to wait to merge back to master as the engine works (albeit with JSON cache files).  MessagePack is implemented but still untested, that will be next after getting the editor building again).

Props to aclysma for continuing to be a pro-hacker with the object loader and nitty gritty pipeline issues.

So, what has changed?  Quite a bit, even outside the fact that Reflect now actually drives all object persistence tasks for the engine assets.  All object persistence is done now outside the actual C++ Reflection module, Reflect.  Meet Persist, which is a separate module on top of Reflect that uses the newly re-christed Translator (formerly Reflect::Data, and before that Reflect::Serializer) system in Reflect to traverse data structures and transact with object member data.  Persist has JSON and MessagePack implementations currently, but adding more is a much easier affair than it was before as every Translator class doesn't need a vfunc for each type of stream format.  Persist and Reflect now (in theory) support aggregate Structures, aggregate Arrays (including arrays of structures and arrays of containers), but some of the edge cases may be untested, and potentially have bugs, so watch out for those.

Regarding Translators, every member variable of every class in the codebase has a Translator that abstracts operations on the data type of that member, and as such Translator classes are stateless (they can't store the data state the transact), but this means we don't have to heap alloc them during file load/store (a *very* good thing).  Member type deduction is now significantly improved as we no longer require container type permutation (no more FilePathArrayData), instead we have a general DynamicArray<> and std::vector<> Translator that deduce the internal type and transact with it's appropriate Translator object.  This *significantly* simplifies the implementation of every Translator class, and is a significant decrease in the code footprint of Reflect.  I can't understate how much better of a neighborhood Reflect is after this change.  Feels good, man.

Also, aclysma made some significant simplifications in the object loaders, but I will let him speak to that.

So next up:
* Get Inspect, SceneGraph, Editor building and running
* Switch the cache file format to MessagePack (for speed and concision)
* Strip support for wchar_t on windows (completion of utf-8 everywhere)
* Figure out how the hell to get SceneGraph sort of functionality in our engine Assets
* Get the Editor parsing the engine Asset tree and displaying internal engine state