Added null guards for the String argument to the ctors.
a number of API changes:
  - use of variable argument lists decrease the size of the API significantly as well as the size of its implementation
  - added a number of "make" methods to Type, which take an IValueFactory as argument. Each types knows how to make values of its type, by calling the right method in IValueFactory. Using dynamic dispatch we can remove the need for a large number of if-then-elses in the code that deals with NamedTypes.
  - NamedTypes are not stored in values anymore. Since they are type aliases this is not needed anymore and it simplifies the code drastically.
  
Some more API changes are forthcoming. Please bare with me.
an attempt at completing the double dispatch design that helps getting rid of if-then-else's in client code that produces PDB values. Now you can use ValueType to create all values, subtypes of values can be used to created less kinds of values, and finally VoidType can not be used to create any value.

O yes, I've added VoidType because its existence greatly helps when doing computations with lub.
redesigned immutability feature: all IList, ISet, IMap and IRelations are immutable now. There is no writer interface you can get from them. Instead you get a writer interface from an IValueFactory which will return an immutable value when the done() method is called. This improves thread safety and also client code conciseness.
result types of visitors on types and values parameterized 
added copyright statement
added some doc
fixed docstring
renamed type param R to T for consistency
* refactored implementation and design of Sets and Relations. A RelationType is now a subclass of SetType and IRelation is an extended ISet. This makes it possible to factor out common code, and to make the client of the API oblivious to whether something is a relation. Also, I could now implement (type-safely) an implicit normalization of all sets of tuples to relations. This means that at run-time the implementation guarantees there are no sets of tuples, only relations. All and all another it also results in a reduction of code. 

* Changed the semantics of 'product' on sets and relations. It was some kind of intermediate between a database join and a relational calculus product. Now it is a proper product as in relational calculus or algebra. A join remains to be implemented (if that is actually needed).

* Made all fields of the implementation of Values 'final'. This implies a few changes in the way clone() is implemented (which is used to set annotations on immutable values). It is one step towards a more thread safe implementation of the PDB values.
renamed TreeSortType to NamedTreeType
* added a new type to the type hierarchy 'tree'. This is a container type like list, set, and map. The tree's children are unrestricted (i.e. value). The existing tree types (TreeSortType and TreeNodeType) are now subtypes of this new tree type. The added functionality is thus the ability to deal with trees that have not been defined using a many sorted algebraic signature. This comes in handy when manipulating XML data or ATerm data of which the contract is either undefined or ill-defined. 

* reimplemented the lub and subtypeof methods for all types for clarity and reuse. 
renamed a method
added forgotten accept method
added visitNode
added right implementation of clone method
fixed toString of Tree
added concat to list interface
non-destructive operations on collections automatically create the lub of the element type.
added boolean types and corresponding values