Started RSTC implementation.
Added transitive computation to TTC SSA.
Partial functions, custom division, promise_equivalent_solutions switch.

 * Replaced NTG/TTC predicates with partial functions.
 * Custom division operator // checks for zero and fails
   (it's a partial function).
 * Using a switch with promise_equivalent_solutions on the
   big switches instead of ->/2.
   The proof is actually simple: just show for each arm that, if it's
   entered, all following arms cannot be entered. The B \= D condition
   was actually necessary to guarantee this.

The first two changes were made to make the code more compact.
On the downside they might hide (in the sense of making them net
apparent to the reader) important cases (e.g., the NTG is zero case),
but (at the moment) I think the readability wins over that.
Integrating init_env, sense, match actions into RSTC.
Can handle multiple drivers now (untested).
Car server and main working for test case.
Fixed replay for car server.
Changed cars-server curses loop; added arithmetic typeclass.
Procedure calls now nullary higher order functions.

Before, procedure calls were types and thus explicit parameters of the BAT.
The body of a procedure call was obtained with the proc/2 predicate
defined in the BAT.

We could probably do similar for stochastic actions by replacing each
stochastic action with a unary higher order function which, given the
current situation, returns the `random' outcome.
This would replace the current random_outcome/3 predicate.
(Note that random_outcome/3 actually is not random; the random seed is
somewhere encoded in the situation term and then random_outcome/3 just
deterministically computes a primitive outcome action.)

Maybe we could even implement nondeterministic pick this way?

Finally, one might want a layer on-top of this procedure-less and
stochastic-action-less BATs that allows for cleaner programs.
This layer could be a super-typeclass of BAT that again requires a type
for procedure calls and stochastic actions and then replaces their
occurrences with respective higher-order terms.
Stochastic actions are now unary functions.
First unit test.
Rational number using ints from Mercury compiler.
Extended unit test.
Made torcs-overtake-7.log plan recognition working again.
Changed order of next/2 and lists for concurrency.

1. next/2 does not alternate concurrent programs.
   Previously, when P1 // P2 was decomposed and P1 = (C ; R1),
   we continued with (C, P2 // R1). The idea was that this induces
   some interleaving.
   However, we don't want to induce too much interleavings of
   observations.
   The non-interleaving-inducing behavior seems to be a bit more
   deterministic.
2. next/2 returns the decompositions of P2 first and then for P1
   when given a program P1 // P2.
   This brings observations in front. But then next2/2 applies foldl/3
   to that list and thus reverses it again.
   That was done the same way in the Mercury implementation.
   One also could have let next2/ as it was and use foldr/3 instead of
   foldl/3 in next2/2, but that's less efficient and actually not much
   less confusing, since next/2 is only used by next2/2 and there's no
   other usecase for next/2 on the horizon.

These changes allow for the same results with a lookahead of 4 instead
of 5.
Generally, of course, one shouldn't rely on internals like these.
Re-activated NCurses display in cars-server. Disabled debug output.
Fixed: wrong calculation of min_conf and max_conf.
Removed cars.sh.
Removed coin-Osi-gc from Makefile.

We don't use the standalone solver (that is, COIN-OR embedded linked to
the libosi.so compiled from osi.m). Instead, we use the remote solver
that communicates with the lp-solver binary via AF_UNIX sockets.

To the standalone solver we needed to change the Mercury compiler's
Boehm GC. Probably this led to the "finalization cycle" warnings that
occurred, for example, when we used cars-server multiple times.
poss/2 binary again, I/O args for obs_source, fixed NCurses / custom GC

1. poss/2 is now binary as it actually should.
   Before it had an out-argument for a newly generated primitive action
   which was used to instantiate dummy parameters like the constraint
   parameter, time parameter, and random generator parameter.

2. obs_source typeclass members now all have I/O arguments, particularly
   next_obs/7.
   Before, these were intended to be pure. They actually were, I think,
   although they did I/O in the background. However, there seems to be
   no problem in adding I/O parameters, so I guess it's better that way
   (I thought this would fix a bug, but it didn't, see next point).

3. Fixed issues of Mercury's libpar_gc (Boehm GC) and NCurses 5.9.
   This is connected with the "finalization cycle" warnings from commit
   cefa68fb41350a65a7304d2f54e40e9a6aac2e65 somehow. Anyway, all these
   memory issues are hopefully fixed now.
   The solution is to stick with Mercury's libpar_gc instead of the
   weirdly customly compiled one.
   Then the NCurses compilation script had to be adjusted to deal with
   missing symbol dlopen from libdl. The solution was simple: add the
   -ldl *after* -lpar_gc in install_ncurses.sh.
   Both, cars-main and cars-server now apparently work fine. Even for
   multiple iterations. First time ever.

4. Updated documentation of prgolog.m.