Optimize stattimers

Main change is separating the representation of the timer stack (StatTimer) from
the manipulation of it (ScopedStatTimer).  This makes it easier to keep the different
use cases (top level timers vs non-top-level) separate without having the individual
functions check whether they think they are a top-level timer or not.

I would have expected this to help a bunch but it seems to actually hurt

This roughly halves stattimer overhead, from +80% to +40%
(on a very small benchmark; more complex benchmarks probably
have lower overhead)

I don't think we regularly run make check anymore, and it's a pain
to make sure the user has an up-to-date gcc (would need to come up
with a good set of instructions for anyone on 12.04).  So just remove
it from make check for now.

tp_richcompare

virtualenv_test currently takes ~7m for me.  we should probably move
most of the stuff it does to the "extra" tests, but for now at least
make `make check` not fail.

int, long, str, tuple, type

int and long are implemented using tp_compare in CPython,
which is the old-style comparison method.  I don't really understand
its semantics which rely on type coercion, and we don't have the
methods it needs, so just implement it as tp_richcompare for now.
I think this is still an overall compatibility improvement.

str_richcompare is very odd where we have to do some weird things
to convince the compiler to produce the best code it can.

The notable places that are changed are PyEq, PyLt, and
compare/compareInternal.

The old codepaths are still in there (though thankfully
now with reduced duplication with cpython), since for anything
that defines a Python-level __lt__, it's better to call that
with our rewriting support, rather than calling it through
slot_tp_richcompare.

The control flow is kind of messy, since I don't think we
know what the right long-term organization is for these kinds of
things.  But basically, it's:
- if we can't rewrite, just call the C slot
- if we can rewrite, and we think calling tp_richcompare is profitable
  (ie it's not slot_tp_richcompare), we call that and emit a call to
  it in the patchpoint
- otherwise, we try calling the python attribute

Actual conversion of our attributes to tp_richcompare in the next commit.

Reduce string allocations

and have the compiler pick the best way to convert to StringRef

I was running into some cases where we had StringRefs but would call
boxString which takes an std::string.  So hopefully this change
makes things cleaner and (slightly) faster.

The motivating one was classLookup(), since this happened
extremely frequently (once for every old-style instance
lookup), but I decided to go through and get some others.

for getattrFunc use getattrInternal instead of getattr

Float pow

getattr throws an exception if the attribute is not present.  getattrFunc already throws the same exception (if there isn't a default value passed in).

Add a section-ordering script

I think this lets us specify that certain functions should be
put together at the end of the text segment.

This is inspired by a similar feature of HHVM's build, though the goal
for us for now is just to improve performance consistency rather
than overall performance.  Hopefully soon/eventually we can do
profile-guided sorting like they do.

Fix some issues with the way we build libunwind

First, that we would only apply our patchset once.  If we ever revert the
patches (I'm not sure under what conditions that happens), we previously would
never apply them again.  Attempted to fix this by adding a special patch that
adds a new file that CMake looks for; if the file doesn't exist, cmake runs the
patches again.

Second, that we didn't rebuild libunwind if we apply new patches.
I'm not sure if there's a good general solution to this, but I was able
to figure out how to force libunwind to rebuild if we need to rerun the
patch command.  It took some hacking since CMake doesn't track dependencies
on external projects, so we have to add some custom dependencies.

remove redundant -Wno-sign-cmopare

Switch hash to using tp_hash

We weren't even doing any rewriting for hash, so there's not much
downside.  This also cuts down on boxing quite a bit since
we can usually avoid boxing the hash value.

Perf investigations

Coming from looking into regex performance; re_compile is reduced
from django-template startup, and dict_hashing_ubench is reduced
from that.

Also, quiet some debug output

use llvm::StringRef instead of std::string typeNew

turns out we allocate/free the same std::strings for every slot name, for every typeNew.
instead do it once, when we create the slotdefs array.  Also, use llvm::StringRefs instead of
std::strings since we already have them in setattrGeneric (the other caller of update_slot.)

Add UTF8-BOM support, int.bit_length, function.func_doc, fix '(-1)**0'

Python-level sampling profiler