suc: dive first to the moves that put more stones
board: make the size a template parameter

- will allow to move that members out that depend on the size solely
board: do not store the neighborhood per object but per board size

- gives quite a speedup since it avoids many memory copies
move functions to set up the neighborhood near to its use place
do not store the set of taken stones but recalculate it when needed

- note: is needed only for leafs
store available_stones instead of increased_largest_group and use it to
restructure winner such that the successors are just traversed
inline successor into winner to avoid building _all_ successors

- give quite some speedup as the put requires to determine the size of
  the largest component
do not store free fields in a set but calculate it on the fly
do not check the size of free_fields, is done in the loop again
implement traversal that returns just the maximum component size
avoid to build to list of free lists explicitly

- instead iterate over stones on the fly
inline taken and size_of_components into size_of_components_of
inline sizes_of_components into in_front

- do two traversals in parallel there
implement unput and avoid to copy boards in winner
board: forbid copy, move, assignment
implement board.normal
apply the inverse transformations in normal

- will allow to calculate the minimum lazy
unify the application of the translations
do not recalculate the translations but use of static member
normal: calculate lexicographic order on the fly