Invokable refactoring and clone design update.


Invokable refactoring:

- Removed interface Invokable
- Moved Invokable's inner interfaces to new package
nl.grim.common.type.invokable
- New class InvokableException. Every invokable interface's function
throws it
- All permutation generators now throw InvokableException
- GenObjectClone now throws InvokableException, wrapping
CloneNotSupportedException


Clone design update:

- CloneProducer is renamed to CloneableProducer. No longer does this
design (contractually) guarantee the clone() method returns a clone of
it's own object, 
- The CloneableProducer now specifically returns it's own type with the
clone() method. It only promises to return a CloneableProducer, not the
actual type of the implementation, though the implementation could make
that promise
- Because the CloneableProducer extends java.lang.Cloneable, and it
always returns it's own type, it can promise to always return a
Cloneable (aside from any runtime desicions to throw a
CloneNotSupportedException)
- No producer can create objects of a type that can't produce objects of
it's own type. In other words: either a producer creates objects of it's
own type, or it creates producer objects that can do just that, but it
doesn't extend any further than that
- Though may seem counter intuitive that an object's clone method would
return a type different from itself, java's clone design allows much
more than that while being completely obscure about it by always
returning the type Object. This design forces it to be publically
visible what the clone method returns
- Any CloneableProducer implementation that doesn't return it's own type
inherently can't be cloned, any attempt to circumvent this would
disagree with it's own design. Simply put: A CloneableProducer that
creates some other type with the clone() method would by concept not be
a Cloneable. You could within the implementation itself still call
super.clone() of course (and it already implements the interface
java.lang.Cloneable), but the result from that could never be the return
value of it's own clone implementation
- The clone generator is currently still being scrutinized because it
expects only CloneableProducers that produce their own type, which
expects more restrictions than the current design guarantees


Project changes:

- Changed Java version from 1.7 to 1.8