Improve performance for many new fields introduction in mapping

When we have many new fields keep being introduced, the immutable open map we used becomes more and more expensive because of its clone characteristics, and we use it in several places.

The usage semantics of it allows us to also use a CHM if we want to, but it would be nice to still maintain the concurrency aspects of volatile immutable map when the number of fields is sane.

Introduce a new map like data structure, that can switch internally to CHM when a certain threshold is met.

Also add a benchmark class to exploit the many new field mappings use case, which shows significant gains by using this change, to a level where mapping introduction is no longer a significant bottleneck.
I'm not sure this is the right fix. If you pull a reference to the values, add values and then pull an iterator, the iterator will not see the values that have just been added. I think it should rather be:

```java
return new Iterable<V>() {
  @Override
  public Iterator<V> iterator() {
    final ImmutableOpenMap<K, V> immutableMap = UpdateInPlaceMap.this.immutableMap;
    final ConcurrentMap<K, V> concurrentMap = UpdateInPlaceMap.this.concurrentMap;
    if (immutableMap != null) {
      return immutableMap.valuesIt();
    } else {
      return Iterables.unmodifiableIterable(concurrentMap.values()).iterator();
    }
  }
}
```
So that the iterator to use is decided at the time when it is requested instead of ahead of time.