Defeat a macro in polygon_collision_detection.cpp

(no notable performance impact)
polygon_collision_detector.cpp naming/whitespace refactor

get_intersection->get_first_intersection

rename
get_first_intersection(line_segment, convex_polygon)'s helper
to planar_get_first_intersection and put it in a helper namespace.
don't construct temporary shape for part of collision-detection

This saves about 10% of CPU time in default scenario, and
has no notable speed effect on pressure_tunnel.
Avoid using tiles as shape further (for performance).

This saves about 10% CPU time on pressure_tunnel,
and about 3% on the default scenario.
Improve bbox iteration docs per Eli's feedback.
remove old bbox_collision_detector traversal interface (now unused)

...since I finished the iteration interface intended to supercede it!
Add a way to debug-check bbox_collision_detector iterator validity

+#ifdef BBOX_COLLISION_DETECTOR_DEBUG
+  // If you're not sure if you're invalidating iterators by container
+  // mutation (insert/erase), this can check, but it uses space
+  // in multiple places so it's #ifdefed.
Possible compiler portability: use BOOST_NOEXCEPT not noexcept

e.g. if we make GCC 4.5 supported it helps, and it's easy to do.

see

http://www.boost.org/doc/libs/1_49_0/libs/config/doc/html/index.html#boost_config.configuring_boost_for_your_platform.the__boost_config_hpp__header

http://www.boost.org/doc/libs/1_49_0/libs/config/doc/html/boost_config/boost_macro_reference.html#config_features

http://www.boost.org/doc/libs/1_49_0/boost/config/compiler/gcc.hpp
check for overflows accessing borrowed_bitset
add "ceiling" scenarios, vertical mirrors of "flat"
Make the objects visible (because they're bounding_boxes)

...which they have been for a while.  They've just been
invisible for a while.
tweak laser location

so that in pressure_tunnel with the upcoming new tile shape semantics,
they'll still be able to destroy anything. (starting inside water
& rock is weird, as laserbeams currently terminate at those elements.
they still do in pressure_tunnel, but now their beams start inside
rock & not at all in water - makes sure they won't be hitting
water first and thus destroy nothing.)

P.S. replaced n<<10 with the more-understandable n*tile_width.

P.P.S. This change slows down old(current)-tile-semantics
pressure_tunnel by a factor of 2.25 at frame 150, and makes
it have about 10% more objects... perhaps the lasers being aligned
with the holes between the tiles made the rock fall apart faster and
thus the water simulation goes somehow different that takes less
time. or something.  Interesting.  This is good news for
new-tile-semantics speed in pressure_tunnel, as the new speed
does not suffer (in fact the new one's CPU time is 20% better in
this new laser location than the old(current) tile semantics in the
new laser location, but the new tile semantics' new pressure_tunnel
also has about 5% less objects at frame 150, so that could easily be
due to legit simulation semantics differences we can't predict).

old-semantics default scenario also becomes 15% slower
(in frames 10-20) due to this change, but the default scenario is
so fast anyway that little things about the simulation could easily
change its percentages...
rename a fine_scalar->tile function

convert_to_smallest_superset_at_tile_resolution
->
get_tile_bbox_containing_all_tiles_intersecting_fine_bbox

because the latter is clearer about what we need in the one case
where we need it, in the (upcoming) case where tiles overlap
at their edges in fine_scalar space.

Note that this will (in new not-yet-committed tile semantic)
make alternated applications of
  convert_to_fine_units(tile_bounding_box)
and
  get_tile_bbox_containing_all_tiles_intersecting_fine_bbox(bounding_box)
gradually increase the size of the box every time
you repeat it.  But that's an intrinsic cost we pay
for making tiles overlap (i.e. a semantic we have to
be aware of while writing simulation code).  See
soon-upcoming comment for why *not* doing so is worse.
trivial refactor

This is better for avoiding signed int overflow (probably
unimportant here, but there's no harm ordering things in a
careful way).
trivial refactor for clarity

(separate interesting computation from (min,max)-to-size conversion)
refactor

for parallelism with the nearby code, and with the
upcoming code
Prepare for new tile semantics (but don't switch to them in this commit)

This commit has no effect on performance that I could measure.
shorten dev-build.py - add a function

(yes, the flush()es are - at least some of them - necessary;
I saw a message from dev-build.py appear too late without them
once - and there are so few messages it doesn't cost much
to do it)
output most commands ./dev-build.py calls

(not the testing --version ones)
Commit new tile semantics!

(There's a compile flag so you can still try the old.)

By the way, all these performance comparisons I've been noting
are with the crazy lasers (-l, --crazy-lasers).

This commit makes default scen 8% slower (frames 10-20),
pressure_tunnel 20% faster (frames 140-150), and stepped_pools
exactly the same speed (frames 140-150).  So I'm not immediately
worried about its performance impact.

(A more logical lookup structure for non-interior tiles than putting
them in the bbox_collision_detector, or even just a separate tile-scale
bbox_collision_detector for tiles, would save lots of RAM and maybe
be more efficient in other ways.  TODO try this sometime later,
not forced by this change.)