Fix infinite recursion bug in .inherited sigs

spec/tapioca/runtime/generic_type_registry_spec.rb

@@ -77,6 +77,19 @@ class GenericTypeRegistrySpec < Minitest::Spec
             refute_same(result, RaisesInInheritedCallback)
             assert_operator(result, :<, RaisesInInheritedCallback)
           end
+
+          it "works for classes that specify a 'loose' sig on .inherited" do
+            # By "loose", we mean `T::Class[T.anything]` instead of `T::Class[SampleGenericClass[T.anything]]`
+            _ = HasNonRecursiveInheritedSig[Object]
+          end
+
+          it "FIXME: breaks from infinite recursion if the sig on .inherited uses the generic type" do
+            # Our swizzled implementation of the `.inherited` method needs to be carefully implemented to not fall into
+            # infinite recursion when the sig for the method references the class that it's defined on.
+            assert_raises(SystemStackError) do
+              HasRecursiveInheritedSig[Object]
+            end
+          end
         end
       end
 
@@ -98,6 +111,39 @@ def inherited(subclass)
           end
         end
       end
+
+      class HasNonRecursiveInheritedSig
+        extend T::Generic
+
+        Element = type_member
+
+        class << self
+          extend T::Sig
+
+          # The correct type would be `T::Class[SampleGenericClass[T.anything]]`, but that would crash Tapioca.
+          # That's not honey Pooh, that's recursion!
+          sig { params(subclass: T::Class[T.anything]).void }
+          def inherited(subclass)
+            super
+          end
+        end
+      end
+
+      class HasRecursiveInheritedSig
+        extend T::Generic
+
+        Element = type_member
+
+        class << self
+          extend T::Sig
+
+          # This sig references an instantiation of this class itself.
+          sig { params(subclass: T::Class[HasRecursiveInheritedSig[T.anything]]).void }
+          def inherited(subclass)
+            super
+          end
+        end
+      end
     end
   end
 end