Initial clj-bdd project template
BDD nodes

The `Node` class represents an individual BDD node.  Pretty basic; it's
just a record containing the variable, value, and low and high pointers.
A leaf node has a value but not a low or high; an internal node has a
low and a high but not a value.  A leaf node also has a special
"variable" that is distinct from any other variable that you could
provide for internal nodes.

BDD nodes will be ordered by using the built-in `compare` function on
the variable objects that the user passes in.  That lets you use
numbers, symbols, whatever.  To provide a custom ordering, you'd have to
create a new type with its own implementation of `compare`.  I'll
probably add the ability to provide a compare function directly when
creating a BDD to make that easier.

A BDD maintains a cache of all of the nodes that have already been
created, so that it's "reduced".  That means that you can compare nodes
using `identical?` — if two nodes are not identical, then they represent
different boolean formulas.
Thread-local "current" BDD

The functions in the previous patch are a bit cumbersome since you have
to pass in a BDD to each one.  This patch adds `with-bdd` and
`with-new-bdd` macros that keep track of a "current" BDD in a
thread-local variable, which lets you leave out all of the repetitive
`bdd` parameters.
Nicer printing of BDD nodes

The new `node-str` function renders a BDD node as a human-readable
string.  The `Node` type now also has `toString` and `print-method`
implementations that use this function.
Comparing BDD nodes

This patch adds a `Comparator` implementation for BDD nodes.  Internal
nodes are sorted by their variables, so that every path from the root to
a leaf in a BDD tree encounters variables in the same order.  Leaf nodes
always sort "larger" than any internal node, and equal to other leaves.
all-where

The `all-where` function returns a lazy sequence of variable assignments
that cause a boolean formula to evaluate to a particular value.  The
assignments only include those variables that must have a particular
value; if a variable is missing from an assignment, then it can have any
value for the overall formula to evaluate to the requested value.
and, or, and not

These are the standard dynamic programming implementations from the BDD
literature.  Unlike the literature, we don't maintain a global operator
cache in the BDD itself; instead, we only maintain the cache for the
duration of a single (outermost) operator call.
Merge branch 'feature/bdd'

* feature/bdd:
  and, or, and not
  all-where
  Comparing BDD nodes
  Nicer printing of BDD nodes
  Thread-local "current" BDD
  BDD nodes