Restore full bypass for the interface-typed expectation case

Moving the structural check into erased_type_conforms? let generic
interfaces (e.g. _Each[Elem], _ToAry[T]) fall through into the
subsequent subtype/parameter comparison, which isn't
generic-parameter-aware for interfaces (see issue castwide#1267) and could
wrongly reject a match the old blanket bypass would have allowed.

Move the check back to where the old ignore_interface? ran, at the
top of conforms_to_unique_type?, so once the interface question is
settled (now via the real structural verdict, with
:allow_unmatched_interface as fallback), nothing downstream runs -
matching the old bypass's shape exactly, just with a real verdict
behind it instead of a blind rule check.

Verified against castwide/solargraph's own downstream
solargraph-rspec integration suite (run_solargraph_rspec_specs
CI job): its 3 pre-existing failures (Array<Integer> => Array
generic-loss cases) reproduce identically on unmodified
castwide/master at the exact commit this branch forked from, so
they're unrelated to this PR either way - this commit is a
defensive correctness fix, not a regression fix.

Author: apiology

lib/solargraph/complex_type/conformance.rb

@@ -41,7 +41,9 @@ def conforms_to_unique_type?
           # :nocov:
         end
 
-        return true if ignore_unmatchable_interface?
+        interface_verdict = interface_bypass_verdict
+        return interface_verdict unless interface_verdict.nil?
+
         return true if conforms_via_reverse_match?
 
         downcast_inferred = inferred.downcast_to_literal_if_possible
@@ -86,14 +88,34 @@ def conforms_via_stripped_expected_parameters?
         with_new_types(inferred, expected.erase_parameters).conforms_to_unique_type?
       end
 
-      # An interface-typed expectation is verified structurally in
-      # #erased_type_conforms?. There's no equivalent structural check when
-      # the *inferred* type is itself an abstract interface (e.g., a method
-      # returns `_ToAry`), since Solargraph doesn't know which concrete type
-      # will show up at runtime, so :allow_unmatched_interface remains a
-      # blanket escape hatch for that direction only.
-      def ignore_unmatchable_interface?
-        inferred.interface? && rules.include?(:allow_unmatched_interface)
+      # Resolves interface-typed conformance before any parameter/subtype
+      # comparisons run, the same way the old blanket
+      # :allow_unmatched_interface bypass did. That's deliberate: RBS
+      # interfaces can have their own type parameters (e.g. `_Each[Elem]`),
+      # and this doesn't verify those (see
+      # https://github.com/castwide/solargraph/issues/1267), so once the
+      # interface question is settled, comparing `expected`'s subtypes
+      # against `inferred`'s would either be meaningless or wrong.
+      #
+      # There's no structural check when the *inferred* type is itself an
+      # abstract interface (e.g., a method returns `_ToAry`), since
+      # Solargraph doesn't know which concrete type will show up at
+      # runtime, so :allow_unmatched_interface remains a blanket escape
+      # hatch for that direction.
+      #
+      # @return [Boolean, nil] true/false if the interface question
+      #   settles conformance outright, nil if there's no interface
+      #   involved (or no verdict could be reached and no fallback rule
+      #   applies), meaning normal conformance checking should proceed
+      def interface_bypass_verdict
+        return true if inferred.interface? && rules.include?(:allow_unmatched_interface)
+        return nil unless expected.interface?
+
+        verdict = structural_interface_verdict
+        return verdict unless verdict.nil?
+        return true if rules.include?(:allow_unmatched_interface)
+
+        nil
       end
 
       def can_strip_expected_parameters?
@@ -109,8 +131,6 @@ def conforms_via_reverse_match?
       end
 
       def erased_type_conforms?
-        return true if expected.interface? && interface_conforms?
-
         case variance
         when :invariant
           return false unless inferred.name == expected.name
@@ -134,23 +154,6 @@ def erased_type_conforms?
         true
       end
 
-      # Whether `inferred` satisfies the `expected` RBS interface (e.g.
-      # `Hash::_Key`, `_ToAry`). Prefers real duck-type verification —
-      # `inferred` conforms if its method stack has every method the
-      # interface itself declares (methods it inherits from `Object` are
-      # ignored, since practically everything provides those) — and only
-      # falls back to the blanket :allow_unmatched_interface rule when no
-      # verdict could be reached, e.g. the interface pin isn't in the
-      # ApiMap.
-      #
-      # @return [Boolean]
-      def interface_conforms?
-        verdict = structural_interface_verdict
-        return verdict unless verdict.nil?
-
-        rules.include?(:allow_unmatched_interface)
-      end
-
       # The methods `expected` declares directly on itself, excluding ones
       # inherited from `Object` and other ancestors.
       #