Fix spacing, avoid redundant test assertions.
Make AttrName comparable.
Introduce AttrList and Renaming as first-class abstractions.

Those classes will be much needed when it comes to engine implementation
and static analysis. For now they do not do more than List/Map, but
delegating work to them will be quickly needed.
Introduce the main Relation interface.

As explained in Relation's documentation we introduce here an abstract
interface for Relation, over the following representations:
* in-memory relations, with the Set-based implementation simply renamed.
* lazy-evaluated relations, through relation algebra and Operator.
* on-disk relations and others, not yet implemented.

The interface provides the public API of Jalf with respect to the OO-styled
relational algebra. The functional DSL simply delegates to the OO API.

The Relation interface is not intended to be implemented directly as the
compiler chain needs access to some concrete internals. AbstractRelation
is the entry point for implementers; the compiler will cast to that abstract
class in an unchecked way.
Add Rename and Project as unary operators.

Rename, Project and future similar classes capture lazy-evaluated
relations in a similar way to an abstract syntax tree. Static
analysis tools (e.g. key inference & type checking) will be
implemented in those classes. Logical optimization also amount at
rewriting this AST using algebra laws prior to evaluation. Last,
JAlf's compiler will use information provided by the AST classes
to convert relational expression to stream of tuples for lazy
evaluation.
Add Tuple#rename and Tuple#project.
Implements the compilation infrastructure.

JAlf's compiler follows a simple delegation scheme.

1. AbstractRelation requires the subclasses (e.g. InMemory or Operator)
   to be able to compile themselves as Cogs.
2. A Cog simply encapsulates a Java 8 stream + some compilation details,
   (including the original expression it comes from). How this stream
   is obtained depends on the kind of relation.
3. The compilation of an in-memory relation simply amounts at obtaining
   a stream of tuples from the underlying Java collection and returning
   a Cog with that stream.
4. The compilation of an operator amounts at compiling operands first
   by delegation to them (see UnaryOperator). Obtained cogs are then
   used for compiling the operator itself (see Rename & Project). The
   compilation work is actually delegated to the Cog itself. Making so
   allows the Cog to be subclassed for specific purposes, such as
   compiling to SQL (a subclass will then encapsulate a query string
   and redefine the compilation callbacks accordingly), implementing
   compilation-time optimizations or allowing specific in-memory
   relations to provide optimized access paths (e.g. through indexes).
5. The default Cog implementation implements the base compilation
   process, that provides rather naïve algorithms through stream
   manipulation.
Implement Relation#equals

As all Relation(s) denote values (even if some of them are lazy evaluated)
we want equals() to apply to those values independently of their actual
representation. This commit implements this on the basic infrastructure,
making the acceptance test pass for now.

The following logic is currently implemented:

1. AbstractRelation checks trivial cases then delegates to the abstract
   `equals(Relation)` method.
2. SetMemoryRelation implements two strategies:
   2.1 against another set-based (through underlying collection equality)
   2.2 against an arbitrary stream (through tuple inclusion).
3. Operator implements two strategies too:
   3.1 delegates to the in-memory `other` relation if it is one
   3.2 loads itself into memory to make such a delegate call.

The current strategy is not optimal at all, even if it basically works.
Possible optimizations include

1. loading the smallest relation into memory in strategy 3.2) above.
2. implement comparison of ordered streams instead of 3.2.
3. avoid the delegation complexity by extracting equals responsibility
   to another abstraction (?)