We mostly use classical C strings, but the memory management around them
can get confusing and error prone. Let's use std::string for the cases
where we need to return a newly allocated string.

Avoid having our own custom stuff and instead use the modern, standard
types, for familiarity.

This allows us to separate accidentally unused, from explicitly unused
parameters, which allows us to turn on such checks in the compiler.

Add also missing <stdlib.h> where required.

The generally recommended way is to include it from source files, not
headers. We had a mix of both. Let's try to be consistent and follow the
recommended way.

They have very different purpose, so make things easier to work
with by having multiple directories.

Some platforms draw directly to the screen, which means that updates
will flicker if we draw multiple layers. Prevent this by first
composing the update on a hidden surface.

This will allow us to render more things than just the framebuffer.

Some platforms impose a significant delay per frame, so we need
to separate that from the time spent shuffling pixels.

The complex logic waiting for events didn't result in any added
performance, so use the simpler approach.