Simplify collect_variant_types and split dense desc call

StackableValues#[] already returns a flat Array, so the Array(...).flatten(1)
wrapping in collect_variant_types was redundant noise. Replace it with a
direct .each and update the comment to match reality.

Add an explicit failure-mode note: if Grape ever renames the private ivars
(@converter, @types, @scope), the method silently returns {} and swagger
degrades to the pre-fix broken output rather than crashing.

Split the three-operation desc(pop_desc(...), params: ..., **...) one-liner
into named locals for readability.

Author: numbata

lib/grape-swagger/doc_methods.rb

@@ -105,7 +105,9 @@ def setup(options)
           .output_path_definitions(target_class.combined_namespace_routes, self, target_class, options)
       end
 
-      desc(pop_desc(specific_api_doc), params: specific_api_doc.delete(:params) || {}, **specific_api_doc)
+      specific_desc   = pop_desc(specific_api_doc)
+      specific_params = specific_api_doc.delete(:params) || {}
+      desc(specific_desc, params: specific_params, **specific_api_doc)
 
       params do
         requires :name, type: String, desc: 'Resource name of mounted API'

lib/grape-swagger/request_param_parsers/route.rb

@@ -58,16 +58,19 @@ def fetch_inherited_params(stackable_values)
       # @converter, so we rebuild a name => types map keyed by the fully-qualified
       # param name (e.g. "group[inner]") to match route.params keys and avoid
       # clobbering same-named params at outer scopes.
+      #
+      # NOTE: @converter, @types, and @scope are private Grape ivars. If Grape
+      # renames them, this method silently returns {} and swagger falls back to
+      # the pre-fix broken output (coercer inspect string) — not a crash.
       def collect_variant_types(stackable_values)
         variant_types = {}
         return variant_types unless defined?(Grape::Validations::Types::VariantCollectionCoercer) &&
                                     defined?(Grape::Validations::Validators::CoerceValidator) &&
                                     stackable_values.respond_to?(:[])
 
-        # `flatten(1)` only collapses the inheritance-stack levels (StackableValues
-        # stores `[[...level1...], [...level2...]]`); avoids descending into
-        # validator internals if any ever implements `to_ary`.
-        Array(stackable_values[:validations]).flatten(1).each do |validator|
+        # StackableValues#[] concatenates inheritance levels and always returns
+        # a flat Array of validator instances — no wrapping or flattening needed.
+        stackable_values[:validations].each do |validator|
           next unless validator.is_a?(Grape::Validations::Validators::CoerceValidator)
 
           converter = validator.instance_variable_get(:@converter)