Basic directory structure for the project
Delete placeholder files

They were necessary for Git to detect those directories
Create solution and initial project

Also add ignore rules for Debug, Release and bin folders within the
project.
Adds a Classic project and tests everything links

Creates a basic CEntity class and uses it so compiling, linking and
executing work as intended.
Adds Release configuration

Also adds special naming to Debug artifacts (adds '_d').
Declares basic methods for entities

Some of the most important methods aren't implemented yet and some of
the classes it depends on don't exist.
Sets base version of entity-component relationship

With basic methods implemented and basic entity and component classes,
it's a working base.
Still missing some classes (CLevel, CLevelData) and some concepts like
factories.
Adds basic message structure and behavior

Also ties it to previous entity-component relationship, adding an
extensibility point for messages.
Adds a basic Level concept, to control entities

A level is a container of entities and will be built from a file later
on.
Also, there's some folder refactor to separate concepts.
Fixes typos

Children components -> child components
Creates the basic EntityFactory concept

It doesn't build any entity yet
Adds blueprints and reads them from a file

A blueprint is a definition of entity types and the components which are
associated to those entities. Types and components are defined as
strings.
Adds basic entity creation to the EntityFactory

It still won't take components into account.
Adds the ComponentFactory but doesn't work yet

Tried creating a basic Graphics component to test it, but it's failing
because it's not getting registered into the factory.
Commiting so any change trying to fix it can be reverted.
Fixes component's regist. into ComponentFactory

Also, cleans up some comments and unnecessary code.
Adds a LevelFactory to read levels from file

Declares the LevelEntry, which is the structure which defines data for
each entity in a level, and a way to parse it from a stream.
Still a work in progress since it's missing the properties data
structure (it's got some prints for now).
Adds property parsing for entities in a level

Entities in the level are built (they have their components, and the
data can be used), but their components don't receive their
initialization's second step. That means they can't yet access that
data.
Also, it fixes some compiler warnings.
Adds level initialization with data for entities

Adds some test data to the test level and test component (Graphics).
Adds the Application: the entry point

The application is the entry point of a game which uses this
architecture. It performs its life cycle and that includes the life
cycle of other abstractions in the architecture.
Adds a way to safely delete entities

Entities which are requested to be deleted will be enqueued and not
deleted during level's tick, They will be deleted after every entity is
ticked and there's no iterator running around them.