Add `Hash#map_values` to ActiveSupport to simplify a common pattern

Keys remain the same, but the values change.

Didn't get a chance to convert existing code, I'll skim through the code base to make use of this later this afternoon.
Given that this is a lower-level utility function, I think it's worth optimizing it to not use `.dup`:

```ruby
require 'active_support/all'

class Hash
  def transform_values_without_dup
    new_hash = self.class.new

    each do |key, value|
      new_hash[key] = yield(value)
    end

    new_hash
  end

  def transform_values(&block)
    dup.transform_values!(&block)
  end

  def transform_values!
    each do |key, value|
      self[key] = yield(value)
    end
  end
end

require 'benchmark'


HASH = { a: 'foo', b: 'bar', c: 'baz' }
HWIA = { a: 'foo', b: 'bar', c: 'baz' }.with_indifferent_access
REPEAT = 1_000_000

Benchmark.bmbm do |x|
  x.report("transform_values") do 
    REPEAT.times do
      HASH.transform_values { |v| v + '!' }
      HWIA.transform_values { |v| v + '!' }
    end
  end

  x.report("transform_values_without_dup") do
    REPEAT.times do
      HASH.transform_values_without_dup { |v| v + '!' }
      HWIA.transform_values_without_dup { |v| v + '!' }
    end
  end
end
```

```
Rehearsal ----------------------------------------------------------------
transform_values              16.150000   0.100000  16.250000 ( 16.246564)
transform_values_without_dup  12.580000   0.070000  12.650000 ( 12.656243)
------------------------------------------------------ total: 28.900000sec

                                   user     system      total        real
transform_values              15.380000   0.020000  15.400000 ( 15.389264)
transform_values_without_dup  12.540000   0.050000  12.590000 ( 12.588670)
=> [ 15.380000   0.020000  15.400000 ( 15.389264)
,  12.540000   0.050000  12.590000 ( 12.588670)
]
```

Not using `dup` gives ~20% performance gain.