Fix C compiler warnings for robdd.m.

When compiling the library directory, we used to get C compiler warnings
about assigning ints to pointers, because on many machines an int is 32 bits,
while pointers are 64. The problem was in robdd/bryant.c, which is bodily

robdd/robdd_conf.h.in:
    New autoconfigured file that specifies what integer type to use
    in robdd nodes (it is now given the typedef name MR_ROBDD_int),
    and how many bits it has.

configure.ac:
    Build robdd_conf.h from robdd_conf.h.in after gathering the info it needs.

robdd/bryant.[ch]:
    Replace almost all uses of ints with MR_ROBDD_ints. The only exceptions
    are the places where int is used as a bool, and where it is used
    as a comparison result (where we need distinguish only between -1, 0, 1).

    In places where MR_ROBDD_ints are printed out, print them with %ld
    after casting them to long.

    Replace the only use of unsigned long, in bitmasks, with MR_ROBDD_uint,
    the unsigned version of MR_ROBDD_int. As far as I can tell, it always
    should have been the same size as the signed ints (and on most 32 bit
    architectures, it was, although by accident).

    Note that bryant.c does NOT compile if e.g. MR_ROBDD_STATISTICS
    is defined. However, that is not the fault of this diff; even the
    version before this diff (from 2004!) had that problem.

    Fix some obvious formatting issues.

    Delete some functions that were declared but never called. (In fact,
    one wasn't even defined :-()

library/Mmakefile:
    Rebuild robdd.o if any of ../robdd/{bryant.[ch],robdd_conf.h} is modified.
Use a better algorithm for unwinding version_arrays.

The old version_array rewind code used linear stack space in order to
perform it's updates in the right order (newest to oldest) by following the
structure's next pointers (which are a oldest to newest list).  I previously
introduced week prev pointers so that walking over this structure newest to
oldest could be done with constant stack space.  However that is less
efficient than the method suggested by Peter Wang.

Peter suggested using a bitmap and traversing oldest-to-newest, marking
each update in the bitmap and checking the bitmap before making any update.
Thus preserving older values over newer ones (which is good, this code
_rewinds_ updates).  This patch implements Peter's suggestion and removes
the prev pointers from the structure for C and Java backends.

Thanks to Peter Wang for giving me a hand with C#.

library/version_array.m:
    As above.

runtime/mercury_bitmap.h:
    Add some macros for initialising bitmaps and testing, setting and clearing
    their bits.

library/bitmap.m:
java/runtime/MercuryBitmap.java:
    Move the Java MercuryBitmap class into the runtime library.  This makes
    it easier for other standard library modules to use this Java class.

library/bitmap.m:
runtime/mercury_dotnet.cs.in:
    Move C# MercuryBitmap class into runtime/mercury_dotnet.cs

library/bitmap.m:
    Add extra methods to the C# MercuryBitmap class.

tests/hard_coded/version_array_test.exp:
tests/hard_coded/version_array_test.m:
    Ensure that the test verifies that rolling back updates to a version
    array rolls back changes in the correct order: If two updates modify the
    same cell, then the older one should be visible in the result.

    Use longer arrays so that the bitmap used in the rollback code is more
    than one byte in length.