* I think it's better to rely on `Module#name` rather than `Module#to_s`.  Ruby explicitly provides `Module#name` so you can get the string form of the module's constant...whereas `to_s` is a more general protocol that ruby uses for string interpolation (and other places) and thus the user may have overridden it.
* Given the goal of eventually working with the module referenced by the constant, it seems wasteful to turn it into a string here so that we can later resolve it back into a constant.
* Consider the case of an anonymous class or module: `to_s` will return something like `#<Module:0x109415280>`.  `name` will return `nil`.  While it's arguable whether it's useful to support this case, I think it's best to support it unless there's a specific reason not to.

What if we created a `ModuleName` class to encapsulate this?

``` ruby
module RSpec
  module Mocks
    class ModuleName
      def initialize(module_or_name)
        case module_or_name
          when Module then @module = module_or_name
          when String then @name   = module_or_name
          else raise ArgumentError,
            "Module or String expected, got #{module_or_name.inspect}"
        end
      end

      def module
        @module ||= Constant.original(@name).original_value
      end

      def name
        @name ||= @module.name
      end
    end
  end
end
```