Also includes a very important cosmetic whitespace change.

Drive-by elimination of an age-old TODO. :)
Code should be functionally equivalent. Changes:

 - Remove broken code under CONSISTENCY_CHECK.
 - Transform to chip-away style.
 - Remove braces around single statements.
 - Declare variables at top of function.
 - Shorten some variable names (tmp_res and bit_length).
 - Limit line length to 80 columns.

A very first step. This implementation still expects all input in a single
chunk but allows the use of the iterative API. If the parser attempts to read
past the first chunk, the parse fails.

Contains some comments for next steps towards full support.

Adds tests for the single-chunk case.

default of k=1 is used.

that we also check to confirm both engines have consume the same number
of tokens (and thus have actually both arrived at the same state for the
same partial input stream)

Using _POSIX_C_SOURCE in the middle of a header is incorrect and may work unreliably because of multiple-include guards

fixes issue #83

hammer/hammer#83

doh! fixes issue 92 again.

tentative commit. this should solve issue 92, but isn't working, yet.

the idea is to taint any memoized follow set that hit a recursive loop,
directly or indirectly. the recursive calls (h_follow_rec) are allowed to use
these intermediates, but propagate the taint. the top-level routine (h_follow)
places the original taint on its result and may remove it at the end. it will
not return memoized results that are tainted (but compute them afresh).

without it, our test for issue 92 is no good (will always pass).
we could probably officially put it back if we simplify "dead"
symbols (that have no productions) out of the grammar beforehand.

there is a case where fs can be empty: when reducing by lhs would lead to
certain parse failure, by means of h_nothing_p() for instance.

fixes issue 83.

cf.
hammer/hammer#83

this makes the computation more wasteful but avoids issue 92. intermediate
results could end up in the memoization table and be treated as final by
later calls to h_follow(). this problem could appear or not depending on the
order of nonterminals (i.e. pointers) in a hashtable.

#92