Shorten cardinal-direction code.

Making cardinal_direction_vectors constexpr means it's no longer
emitted in the translation units that don't use it, yay.

I also renamed add_to to increment and added a couple more utility
functions.
limit to around 60 FPS max
fix race condition when quitting: increment revision

(Also refactor so that the variable assignment is shared.
Add log messages when quitting, showing quit status.

This helped me debug it and might help others because OpenGL
is finicky.
de-inline log constructor/destructor
remove out-of-date comment
Make the rendering thread semi-interruptable.

Now the rendering thread checks an atomic flag frequently
and if/when it's set, returns early rather than finishing the
potentially large number of OpenGL calls it was queued up to do.
This makes quitting with Esc quick, without risking the wrath of
interrupting a GL implementation mid-call nor making it hard to
deallocate the GL buffers we allocate.
make WARNING_FLAGS only use flags that the compiler recognizes,

and add Clang's equivalent of GCC's fmax-errors, and
reduce the number to a limit somewhat more useful with
huge template error messages.

In order to get Clang not to warn about -ferror-limit every time,
we had to add -Werror to the checks to that Clang's warning
about not recognizing -fmax-errors could be upgraded to an error.
LOL.  Also check_cxx_compiler_flag cannot handle flags that have
spaces in them, because it splits on spaces...
log a message just before calling exit()
fix existing harmless warnings from Clang
Add (Clang-only) warning flag for global constructors & destructors.

They are inefficient, and racy.  They bloat startup/shutdown time and
binary size.  Destructors race between one thread calling exit()
and destroying global objects, and other threads using them.
Constructors in separate translation units have arbitrary
initialization order.  Neither of these is something
we can't deal with moderately easily, but it's nice not to have any
and we can do it!  Also, the work in doing it possibly helps things
in other ways.

Setting this warning is the first step to finding and eliminating them.
Make world_constants.hpp constants be constexpr

Which makes them certain to be non-runtime-constructed
(-Wglobal-constructors),
and also not emitted in translation units that don't use them.
make world center coords (world.hpp) constexpr
fix bounds-checked-ints
Make input_representation key_type constexpr (and smaller)
make specific_worlds not require a global init constructor

make_world_building_func() is linear in the number of scenarios
currently but there are only a few dozen and it's only called
once per run!  It's not worth the moderately trivial effort to
make it asymptotically faster with this system now.
gl_data_preparation.cpp: make global data constexpr
prevent a deprecated part of Boost from creating global constructors
constexpr another global.

Now the only global-constructors left are the tests,
and boost test framework with the auto test cases works that way.
I'll be able to fix that too, and it might even help fix the
way my clang's build is looping when it tries to run the tests...
in a bit, though.
don't have side-effects inside an assert()

It's easy to miss visually, and can be compiled away if NDEBUG
is defined!