Add missing return statement
Remove unused variable in condvar.c
Correctly initialize stack info for main context
Make futex.h suitable for C++
Redesign of futex code for higher performance

The old futex code used to maintain a single global list for all futexes being
waited on by the app.  We have redesiged this to follow a "list-of-lists"
pattern, where the innermost list only contains futexes all waiting on the
same uaddr.  The outerlist (which could be implemented as a hash), just helps
us find our list of threads waiting on the same futex.  The outerlist is
maintained as a wait free list for higher concurrency, and the innerlist is
protected by a lock, since there usually shouldn't be a whole lot of
contention on it and it simplifies the logic alot.

We also add api calls to optimize for the most commone wake_one() and
wake_all() cases of waking up some futexes.
Change semantics of lithe_hart_return()

The old semantics allowed the parent to retain a reference to the child
scheduler even after it yielded its last hart and its child->harts count was
decremented to 0.  This is bad news, because once the child->harts count drops to
0, its fair game for that scheduler's memory to be freed.

The lithe_hart_return() callback on a parent is issued in response to
a lithe_hart_yield() from a child.  The old lithe_hart_yield() call would down
the child->harts count *before* calling lithe_hart_return() on the parent,
passing it a (possibly dead) reference to the child.  The lithe_hart_return()
call then acted as a *second* hart entry point into a parent scheduler, and it
was up to them to ensure that lithe_hart_return() never returned, and acted
just like a lithe_hart_enter().

These semantics forced the parent scheduler to implement lithe_hart_return()
as *both* a way of doing book keeping on the child *as well* as an explicit
call to its custom hart_eenter() function (or some other function that never
returned and knew what to do with the newly returned hart). In retrospect,
these semantics are a little weird to begin with, since it's nice to only have
a single entry point to into the hart.

The new semantics of lithe_hart_return() now just inform a scheduler that
a hart is being returned to it (but it is still "owned" by the child while the
hart_return() call is executing).  The parent should now use it *only* to do book
keeping, with the actual hart itself popping in on hart_enter() once
it is ready. This separation is necessary so that the parent can be informed
that a hart is about to be returned by a specific child, but maintain proper
reference counting of harts so that dead references to the child scheduler
aren't passed around.

These new semantics have two primary benefits:
1) They remove the race of retaining a reference to a child scheduler even
after it has died.
2) They are actually more symmetrical with how the child_exit() callback works
in terms of calling into the parent while the current hart is still "owned" by
the child, and only updating the hart ownership once the callback returns.

With these new semantics a few things needed to change in the base scheduler
so that he could do proper accounting of what harts should be passed down to
the root scheduler and which ones should be yielded.  This is also more
symmetric to how other schedulers are designed anyway:

1) Check to see if any children need the hart
2) Check to see if I need the hart (never true for the base scheduler)
3) Yield the hart back up (to the system in the case of the base scheduler)

Hopefully we can abstract some of the things we've learned how to write for
all schedulers into a library that others can leverage to make scheduler
writing easier in the future.