Merge branch 'fixing_intervals' of git://github.com/nmathewson/timeout into nmathewson-fixing_intervals

add Lua module, move noise into subdirectories, and make build portable by only using POSIX make syntax and semantics

Also, make them check the required invariants for to->expires after
timeout_readd().

Also, actually use the different timeout values in the main()
function (whoops).

William Ahern tells me that the intent here is that timeout_readd()
should always reschedule the timeout at the first time in the future
that is an even multiple of to->interval, as if we had called:

         do {
                 to->expires += to->interval;
         } while (to->expires <= T->curtime);

But of course, that's not efficient.  The implementation strategy
used in this patch simplifies the calculation down to a single %
operation, plus a few additions and subtractions.

To verify the correctness of the formula used here, note first that
        0 <= r < to->interval, and so
        0 < to->interval - r <= to->interval.  Since
        expires' = curtime + (interval - r),
        curtime < expires' <= curtime + interval,
and so the new expiration time is no more than one interval after
curtime.

Note second that since
        r = (curtime - expires) % interval,
        expires' = curtime + (interval - r), we have
        (expires' - expires) % interval =
            (curtime + (interval - r) - expires) % interval =
            (curtime - r - expires) % interval =
            (curtime - (curtime-expires) % interval - expires) % interval =
            (curtime - curtime + expires - expires) % interval =
            0.
And so the new expiration time is an even multiple of interval from
the original expiration time.

Since we have both properties we wanted, this formula should be right.

rename timeouts_cursor to more terse timeouts_it
bumb version numbers

reorder statements in timeouts_get to make TIMEOUT_DISABLE_INTERVALS case simpler, removing need for macro accessors

Merge branch 'optional_intervals' of git://github.com/nmathewson/timeout into nmathewson-optional_intervals

Merge branch 'optional_timeout_ptr' of git://github.com/nmathewson/timeout into nmathewson-optional_timeout_ptr

Merge branch 'timeout_foreach' of git://github.com/nmathewson/timeout into nmathewson-timeout_foreach

Merge branch 'timeout_cb_override' of git://github.com/nmathewson/timeout into nmathewson-timeout_cb_override

Merge branch 'portable_bitops' of git://github.com/nmathewson/timeout into nmathewson-portable_bitops

According to the documentation, 32-bit x86 builds do not have the
64-bit _BitScan{Forward,Reverse}64 intrinsics.

Given these, we can remove the code to check for the zero case.

These currently cover most reachable lines and branches, except the
case where malloc fails in timeouts_open(), the if() branch in
timeouts_readd() (see issue #7) , and some failure cases in
timeouts_check().

This patch includes an intrinsic implementation for these functions
when the compiler is GCC, Clang, or MSVC--or if the compiler claims
to be one of those.  Otherwise, a naive implementation is used.

Tests are included for all of these functions, which turned up a
possible problem: according to the gcc documentation, __builtin_ctz
and __builtin_clz give an undefined result when their inputs is
zero.  I was not able to persuade myself that we always called them
with a nonzero argument.

This field eats a pointer for every struct timeout, and it only
exists in order to enable a set of APIs that omit the 'struct
timeouts' object. For some applications, the convenience of these
APIs is not worth the memory overhead. This patch makes it so
that applications can disable those APIs, and save some memory, by
defining TIMEOUT_DISABLE_RELATIVE_ACCESS at compile time.