Make drawing_*_stuff part of the view_on_the_world

It's similar in generality to e.g. view.surveilled_by_global_display
and the keys that affect that.

(part of a project to consolidate the threaded code to make
threads optional)
Consolidate view input code in one place.

(Pausing/stepping, and esc to quit, are in a separate place.
Simulation effects like moving your robot are likewise separate.)
Clarify microseconds-counting code a bit.
Each simulation thread step gets its own function call (code refactor)
Add the ability to compile/run without threads.

(compile-time only, unfortunately)

This can probably help some testing, & those who don't
want to link to boost threads (the only not-header-only
Boost lib we've used so far).
(Valgrind is not broken by programs being threaded.
I however was testing 32-bit speed (CFLAGS=-m32) and
didn't have 32-bit boost libs, so no-threads was useful
there. (32-bit speed was worse.))

Also add a PRINCIPLE about the unfortunate conditional
compilation I've added.

Also quietly add another missing lasercake-* to clean.
Add more ways to build with Clang

The clang/libc++ way now compiles for me*, but crashes at runtime
in a mysterious way.  Compile-testing is nevertheless useful!

* Clang 3.1; Clang 3.0 crashes while compiling some of my lambdas
last I checked.
Fix standard-compliance thanks to Clang warning.

("warning: C++11 requires lambda with omitted result type
to consist of a single return statement [-Wlambda-extensions]")
Add an initial plausible bounds_checked_int.

It only works on 64-bit processors,
and arithmetic mixing bounds_checked_int sizes doesn't compile
in this version, and it requires a bit much explicit casting
(for paranoia's sake to make sure the user doesn't miss somewhere
that could overflow).
Improve/fix bounds_checked_int significantly.
Finish fixing bounds_checked_int, and actually test all its operations.

This is the first version of bounds_checked_int I got to work
(compile and run correctly) with the rest of the Lasercake code
(commits for that are coming later).
fix the concurrency_utils test
make a way to compile all the sources at once (so you can see if it works)
Add typedefs that will make using bounds_checked_int practical.

polygon_collision_detection.cpp gets some explicit casts from
0 or 1 to rational (non_normalized_rational<polygon_int_type>) [1]


[1] because it wasn't working for me with bounds_checked_int...
maybe it was the fact that it would require *two* user-defined
implicit conversions
(int -> bounds_checked_int -> non_normalized_rational)
which C++ won't do (but it will do a builtin implicit conversion
and a user-defined one).
Make Lasercake math variables almost all signed.

This is because:

C promotes signed to unsigned when you mix their arithmetic,
which can be annoying.  Signed is mildly more useful than unsigned in
most cases (whenever you don't want a modulo type or don't need *all*
those bits for numeric magnitude), and a bit less likely to
accidentally underflow.

Also, if you don't want modulo behavior, signed permits the compiler
to optimize assuming overflow/underflow won't happen (this lets it
believe useful things like (for all int i, i+1 > i) which affect loop
optimization and others).  Normally I would also be nervous about
the undefined behaviour when it *does* overflow.  However,
* we're going to get that anyway, because lots of our numbers do need
to be signed.
* wrapping would probably lead to other bugs in our code even if it
was compiled as fully modulo (-fwrapv -- which [note to self] I might
try adding sometime and see how it affects performance).
* having bounds_checked_int helps convince me that we are not
overflowing in the typical case, even if it's too slow to run in
production.


The tile_physics change was trivial.

The tile change required changing world_center_tile_coord to still
have vast swaths of numeric space on either side of it.  That's all.
Make the rest of the code compatible with bounds_checked_int

This requires including its headers in order to be compatible
with it, but still compiles fine without actually using
bounds_checked_int (as intended, for runtime speed [and compile
speed?] purposes).
Fix a minor int-size limit/bug found in the process of debugging

(It might be better to also check if more is being subtracted from
the velocity than its magnitude, or similar, and do something
sensible in those high-velocity cases.  Such cases probably can't
occur presently for other reasons, but.)
Add the (off by default) way to enable bounds checked ints.

(With optimization in each case,
on 64-bit Linux, GCC 4.7.0, Sandy Bridge i7 CPU
)
runs around 30 times slower than non-bounds-checked.
Add a test for i64sqrt
indent/comment

The "C++11 syntax" comment is targeted to people who know C++
but not this syntax:
making the code base a slight bit friendlier to that lot of people.
Fix test so it actually tests anything.

(tested by adding BOOST_TEST(false) to i64sqrt_test and watching
whether it failed, because all the actual tests still passed
as expected.)

Someday I might learn how to use BOOST_PARAM_TEST_CASE correctly.
I wish the documentation was better (for someone who doesn't yet
know that test library well).