(PUP-9323) Add a level of indirection during unmunge

When the agent converts the resource catalog (downloaded from the server) to a
RAL catalog, it metaprograms a new class for each type of resource, e.g.
`Puppet::Type::File`, and corresponding classes for each parameter/property,
e.g. `Puppet::Type::File::Mode`. The conversion to RAL also triggers calls to
`munge`, `validate` and `unmunge` for each parameter. This gives the parameter a
chance to convert from the DSL form to an internal/canonical form, e.g. "owner
=> root" and "owner => 0" are equivalent.

However, if the parameter's value is deferred, then we won't know its value
until later when the resource is evaluated. So we need to delay calls to
`munge`, `validate` and `unmunge` until after the deferred value is known.

It is possible to intercept calls to `munge` and `validate`, because there is a
level of indirection between the transaction and the munge/validate methods
implemented in a custom parameter. For example, the transaction sets the desired
value on the property[1], which triggers a call to the `munge` instance method.
If the custom type has defined a `munge { |value| ...}` DSL method, then it
metaprograms an `munge_unsafe` method[2], which is called by the `munge` instance
method[3].

However, the `unmunge` logic doesn't have this level of indirection -- the
transaction calls the custom `unmunge` method directly.

This commit introduces a level of indirection to `unmunge` following the same
pattern used by `munge`.

[1] https://github.com/puppetlabs/puppet/blob/7.16.0/lib/puppet/property.rb#L551
[2] https://github.com/puppetlabs/puppet/blob/7.16.0/lib/puppet/parameter.rb#L176
[3] https://github.com/puppetlabs/puppet/blob/7.16.0/lib/puppet/parameter.rb#L430

Author: joshcooper

lib/puppet/parameter.rb

@@ -177,15 +177,15 @@ def munge(&block)
     end
 
     # @overload unmunge {|| ... }
-    # Defines an optional method used to convert the parameter value to DSL/string form from an internal form.
+    # Defines an optional method used to convert the parameter value from internal form to DSL/string form.
     # If an `unmunge` method is not defined, the internal form is used.
     # @see munge
-    # @note This adds a method with the name `unmunge` in the created parameter class.
+    # @note This adds a method with the name `unsafe_unmunge` in the created parameter class.
     # @dsl type
     # @api public
     #
     def unmunge(&block)
-      define_method(:unmunge, &block)
+      define_method(:unsafe_unmunge, &block)
     end
 
     # Sets a marker indicating that this parameter is the _namevar_ (unique identifier) of the type
@@ -415,10 +415,19 @@ def unsafe_munge(value)
   # @return [Object] the unmunged value
   #
   def unmunge(value)
+    unsafe_unmunge(value)
+  end
+
+  # This is the default implementation of `unmunge` that simply produces the value (if it is valid).
+  # The DSL method {unmunge} should be used to define an overriding method if unmunging is required.
+  #
+  # @api private
+  #
+  def unsafe_unmunge(value)
     value
   end
 
-  # Munges the value to internal form.
+  # Munges the value from DSL form to internal form.
   # This implementation of `munge` provides exception handling around the specified munging of this parameter.
   # @note This method should not be overridden. Use the DSL method {munge} to define a munging method
   #   if required.