Move the INLINE pragma after the function.

All other INLINEs are after function bodies.
Improve Foldable instances.

- Employ implementation techniques used in normal folds, i.e.,
  * Inline fold and foldMap
  * Capture the function argument and do not pass it in the worker

  The Foldable.fold is only INLINABLE, because mappend and mempty depend
  only on Monoid dictionary and are fully specified when Foldable.fold
  is specialized. On the contrary, INLINE foldMap to allow the mapping
  function to be inlined.

  This improves complexity by ~60%.

- For Set and Map, add special case for a leaf. This avoids calling
  mempty for the Tips and mappending them with the value in the leaf.
  The improvement is further ~35% for Set and ~30% for Map.

  The leaves are recognized by comparing size of the tree to one. They
  could also be recognized by comparing left and right subtree to Tip,
  but that is slower.

  Also, cases when only left or right subtree is Tip could be
  recognized, but the implementation is still slower than recognizing
  only leaves using the tree size. It can be proved that at least 66% of
  Tips are under leaf nodes, so we miss at most one third of Tips in
  current implementation and do not cause so much code growth.
Improve Traversable instance of Map.

Similarly to Foldable instance (commit #29d3fbcc), add a special case in
traverseWithKey when traversing a leaf. In this case, the Tips under the
leaf are not traversed. The speedup is 25%.

See the log of the mentioned commit #29d3fbcc for discussion of
alternative implementations.