Discovery.

Just a few fixes, a few tools to discover how the data entities need
  to behave to maket his work.
Back to Basics.

I've decided to change the data entities, to hydrate them more
  explicitly, to get around all the serialization issues I'm having.
  I'll also be using hashes as keys in tables, making a Table an
  explicit entity type.  This will help with discrete conditioning
  and graph queries.
In light of all these changes, I'm leaving my noodling code inline,
  commented out, and making sure I'm back to a baseline to begin these
  next steps.
FIX entity serialization.

* Explicitly serializing factors on graphs
* Explicitly requiring Factors in a FactorList
* Using the same serialization interface on a List as an Entity
* Ignoring the verbose YAML format...it works, and doesn't
  need to be portable to other systems.  XMLBIF or just JSON
  will be used for that.
Cleanup fathom.rb

Moved the demonstration code into scratch files.
FIX entity serialization.

Completely rewrote the serialization on the entities.

There are lists of variables now.
The serialization is consistent between a list and an entity.
The parents are always labels.
Full variable lists are being used.
Probably more fixes.
FIX action objects.

This uses the new data entities.  The problem was the entities
  had hidden meanings from the order of the table keys.
The new formats uses hashes for table keys, so that they can be worked
  on directly without mental acrobatics.
Also, added an adjacency list to the graph, removed the variable list
  from the factor, and generally made this thing work.
Added some support tools, but I do have a brittle factory: a_to_d.csv.
There are a lot of calculations that are based on these support files
  not changing.  Unfortunately, either I don't have the stamina to
  build more-forgiving tests, or the nature of this kind of operation
  is just context specific.  What I'm confident of is that the
  observations are being translated into tables, factors and
  graphs in a reasonable way.
Add ConditionTable.

Takes a table (from a Factor, say), and conditions it to only
  include values matching a query.
Takes a Query or a conditions hash.
Allows an Array of matching values for each condition.
  e.g. ConditionTable.execute(table, 'a' => [1,2])
  allows a to be 1 or 2.
Add MarginalizeTable.

Filters variables out of a table.
Re-normalizes the table.
Makes the raw, filtered table available, in case that's useful.
Merge branch 'master' of github.com:davidrichards/fathom