Implement REFINE and SUPPORT

Contrast the new signature of REFINE
```python
    def refine(
            self,
            target_feature_sets=None,
            query_feature_sets=None,
            conditioning_row=None,
            result_out=None,
            sample_count=SAMPLE_COUNT):
        '''
        Determine which queries would inform target features, in context.

        Specifically, compute a matrix of values relatedness values

            [[r(t,q) for q in query_feature_sets] for t in target_feature_sets]

        conditioned on conditioning_row.

        Inputs:
            target_feature_sets - list of disjoint sets of feature names;
                defaults to [[f] for f in preql.feature_names]
            query_feature_sets - list of disjoint sets of feature names;
                defaults to [[f] for f in preql.feature_names]
            conditioning_row - a data row of contextual information
            result_out - filename/file handle/StringIO of output data,
                or None to return a csv string
            sample_count - number of samples in Monte Carlo computations;
                increasing sample_count increases accuracy

        Outputs:
            A csv with columns corresponding to query_feature_sets and
            rows corresponding to target_feature_sets.  The value in each cell
            is a relatedness number in [0,1] with 0 meaning independent and 1
            meaning highly related.  See help(PreQL.relate) for details.
            Rows and columns will be labeled by the lexicographically-first
            feature in the respective set.

        Example:
            >>> print preql.refine(
                    [['f0', 'f1'], ['f2']],
                    [['f0'], ['f1'], ['f2']],
                    [None, None, None, 1.0])
            ,f0,f1,f2
            f0,0.8,0.9,0.5
            f2,0.8,0.8,1.0
        '''
```
with the old tarot signature of SUPPORT:
```python
def support_sample(meta, latent, row_data, column_id):
    '''
    For each feature f (except the target feature column_id), compute
    the expected conditional relative entropy of the observed posterior vs
    the posterior with feature f removed if present or added if missing.
    Letting y~column_id be the target feature and z~f be another feature,

                /                    P(y|observed)
               |      E         log ---------------     if f is observed
               |     y|observed     P(y|observed-z)
      KL(f) = <
               |                    P(y|observed+z)
               |      E         log ---------------     if f is unobserved
                \  y,z|observed      P(y|observed)
    Inputs:
      ...
      row_data of features f and their values (value = None means unobserved)
      column_id of the target unobserved feature (taking value y above)

    Returns:
      A dictionary of (f, KL) pairs, where higher KL = more supporting.
    '''
    ...
```