(PUP-2654) Capitalize each segment of a resource type "label"

When a Resource type is stringified it selects the short notation
(e.g. Fee::Foo) over the longer (e.g. Resource[Fee::Foo]), and
when doing so it should output each segment of the FQN with a
capital letter. The current implementation only capitalizes
the initial letter (e.g. Fee::foo::fum).

This fixes the implementation of
TypeCalculator.string_PResourceExpression to capitalize all segments.
I did a little benchmarking of this. Using the regex ends up being between 2x and 3x slower than using a string for the split:

````ruby
require 'benchmark'

SEP = "::"
FROZEN_SEP = "::".freeze
long = (["word"] * 1000).join(SEP)
short = (["word"] * 4).join(SEP)

iterations = 100_000
Benchmark.bm(23) do |x|
  x.report("long/regex") { iterations.times { long.split(/::/) } }
  x.report("long/string") { iterations.times { long.split("::") } }
  x.report("long/string-constant") { iterations.times { long.split(SEP) } }
  x.report("long/string-frozen") { iterations.times { long.split(FROZEN_SEP) } }
  x.report("short/regex") { iterations.times { short.split(/::/) } }
  x.report("short/string") { iterations.times { short.split("::") } }
  x.report("short/string-constant") { iterations.times { short.split(SEP) } }
  x.report("short/string-frozen") { iterations.times { short.split(FROZEN_SEP) } }
end
````
The results:
````
[11:49:12][Ruby(ruby-1.9.3-p484)][Git(master)] andy:puppet-specifications
> ruby split_bench.rb
long/regex               29.390000   0.020000  29.410000 ( 29.405655)
long/string               9.880000   0.010000   9.890000 (  9.884679)
long/string-constant      9.680000   0.000000   9.680000 (  9.692086)
long/string-frozen        9.720000   0.000000   9.720000 (  9.724015)
short/regex               0.250000   0.010000   0.260000 (  0.244649)
short/string              0.090000   0.000000   0.090000 (  0.093818)
short/string-constant     0.090000   0.000000   0.090000 (  0.083907)
short/string-frozen       0.080000   0.000000   0.080000 (  0.084221)
````

I was actually really surprised that the frozen string was slower than the unfrozen one....