ECSlib should have its own repo and should be imported as submodule

A system should run in parallel with other systems. The tricky part here is that different Systems need the same components so parallelism in those cases is not supported.

The Manager that will handle this should note what component types are being used and with what operation (read/write). A possible implementation for this could be done with the help of the Pool::Get function. This could be split into two - T Get and GetRef. The Get() implementation allows reading, the GetRef() will allow writing. When those functions are called the Manager takes note of that and if the internal state allows for read/write on the particular component, it sets some flags and returns the components. When the System Exits, the flags that were occupied by the system are cleared. But this implementation has a big flaw: what happens if a system uses multiple components at once? If we implement this right, we could: release previously managed components from the Manager flags and only leave the most recent blocking request. Until that request is fulfilled other systems will be allowed to change states of components (or at least only read them - writing components as a system is waiting is pretty dangerous). If the request becomes solvable (the flags are free to be taken) we do not return the components yet, we check if the components that we previously temporarily released can be taken back - we wait until the original state was available. When we regain it, we return with the requested components and we set the flags.

[! READ]
Also, before we do this, events must be changed to be handled by each system in their own execute() phase or in that proximity. Events should be added to a queue that is appended to a listening system when the Subscribe() method is called.

Also running a thread for each system may be the wrong approach - we might want to do coroutines on some threads - we will need to implement the coroutines in an asynchronous fashion.

The return type of Initialize(), Execute(), and Uninitialize() is void. This should be changed to bool in case something fails.

Also, some systems might need to Execute every time but check for themselves if they are enabled or not so that they will "run in stealth mode". We could introduce a StealthExecute() function in the interface that is executed if the systems are disabled.

Another useful parameter for Execute() would be delta - the time from the last execution.