Fix minitest reporter crash with parallel testing (#3602)

### Motivation

Fix crash when using ActiveSupport's parallel testing with the Minitest reporter. When running tests in parallel, ActiveSupport passes a `PrerecordResultClass` wrapper (a Struct containing only the class name) instead of the actual test class, since class objects cannot be marshaled across process boundaries via DRb.

### Implementation

Updated the `prerecord` method in MinitestReporter to handle both regular test classes and ActiveSupport's wrapper objects:
- Renamed parameter from `test_class` to `test_class_or_wrapper` to clarify it can receive different types
- Extract the class name using `.name` (which both real classes and the `PrerecordResultClass` wrapper respond to)
- Attempt to resolve the actual class using `Object.const_get`
- If `const_get` fails (e.g., for Minitest specs with invalid constant names like `"MySpec::when something is true"`), use the original object since it's already the test class
- Continue with the existing logic using the resolved class

This approach handles three scenarios:

- Regular test classes: `const_get` successfully resolves the class
- ActiveSupport's PrerecordResultClass: Contains the class name as a string, `const_get` retrieves the actual class from the main process
- Minitest specs with describe blocks: `const_get` fails due to invalid constant names (with spaces), but we already have the class object

### Manual Tests

To test these changes:
1. Open a Rails project that uses ActiveSupport's parallel testing
2. Run tests using the Ruby LSP test runner
3. Verify that test results are correctly reported in the Test Explorer view

Author: alexcrocha

lib/ruby_lsp/test_reporters/minitest_reporter.rb

@@ -74,12 +74,25 @@ def minitest_plugin_init(_options)
       end
     end
 
-    #: (singleton(Minitest::Test) test_class, String method_name) -> void
-    def prerecord(test_class, method_name)
-      uri, line = LspReporter.instance.uri_and_line_for(test_class.instance_method(method_name))
+    #: (untyped, String) -> void
+    def prerecord(test_class_or_wrapper, method_name)
+      # In frameworks like Rails, they can control the Minitest execution by wrapping the test class
+      # But they conform to responding to `name`, so we can use that as a guarantee
+      # We are interested in the test class, not the wrapper
+      name = test_class_or_wrapper.name
+
+      klass = begin
+        Object.const_get(name) # rubocop:disable Sorbet/ConstantsFromStrings
+      rescue NameError
+        # Handle Minitest specs that create classes with invalid constant names like "MySpec::when something is true"
+        # If we can't resolve the constant, it means we were given the actual test class object, not the wrapper
+        test_class_or_wrapper
+      end
+
+      uri, line = LspReporter.instance.uri_and_line_for(klass.instance_method(method_name))
       return unless uri
 
-      id = "#{test_class.name}##{handle_spec_test_id(method_name, line)}"
+      id = "#{name}##{handle_spec_test_id(method_name, line)}"
       LspReporter.instance.start_test(id: id, uri: uri, line: line)
     end