Fix TypeTable round-trip for Kotlin top-level functions

[steve-aom-elliott]

Summary

Three interlocking bugs in TypeTable caused Kotlin top-level functions (top-level regular functions and extension functions) to lose method type attribution when KotlinParser received a classpath sourced from a TypeTable-synthesized directory (as mod does for downloaded LSTs) rather than the original jar. The symptom: J.MethodInvocation.getMethodType() returns null for calls like jacksonObjectMapper() (from jackson-module-kotlin), and MethodMatcher/UsesMethod therefore cannot match them.

The three fixes

1. ACC_SYNTHETIC methods were filtered out. Kotlin extension functions compile to public static final synthetic on a *Kt facade class, so they were being dropped at write time. Now filter on ACC_PRIVATE only (and skip <clinit>), matching what's needed for type attribution.

2. InnerClasses attribute was not captured. Kotlin FIR silently fails to resolve methods on a class whose @kotlin.Metadata.d1 protobuf references inner classes (lambdas, companion objects, etc.) unless those inner classes are declared in the class's InnerClasses attribute. The Writer's ClassVisitor didn't override visitInnerClass, so every round-tripped class came out with an empty InnerClasses attribute. Now serialize each entry as name,outerName,innerName,access into a new innerClasses TSV column, and replay them on the Reader side before any other class events so ASM writes them back out.

3. META-INF/*.kotlin_module resources were dropped. The Kotlin compiler uses these files to map package names to their facade classes (com.fasterxml.jackson.module.kotlin → ExtensionsKt). Without it, the resolver can't find the top-level function's owner. Store .kotlin_module files as resource rows using a classAccess = -2 sentinel with base64-encoded content in the constantValue column, plumbed through a new ResourceConsumer callback on Reader.read() so callers can persist them alongside the synthesized .class files.

Tests

• MethodMatcherTest#libraryTopLevelFunctionPopulatesMethodType — asserts method type is non-null for jacksonObjectMapper().
• MethodMatcherTest#usesMethodMatchesLibraryTopLevelFunction — end-to-end UsesMethod match on the Kotlin top-level extension function.
• TypeTableTypeAnnotationsTest#columnOrderCorrect — updated for the added column.

Both Kotlin tests use KotlinParser.builder().classpath(\"jackson-module-kotlin\"), which resolves via the shipped TypeTable — exactly the code path that was broken.

Test plan

• ./gradlew :rewrite-java:test --tests "org.openrewrite.java.internal.parser.*"
• ./gradlew :rewrite-kotlin:test --tests "org.openrewrite.kotlin.MethodMatcherTest"
• Full CI

[sambsnyd]

The explanation makes sense and the fixes look reasonable.

The various places where loosely typed columns are accessed by magic indexes was already there before this PR. But code like:

                            // Resource row — see Writer.Jar.writeResource
                            String resourcePath = fields[4];
                            String base64 = fields.length > 17 ? fields[17] : "";

or

                        String artifactVersion = fields[1] + "-" + fields[2];

would be more readable and maintainable if we had some struct or view which gave each field a name and proper type rather than just an index and String.

[sambsnyd]

Even with the comment this feels a bit opaque, constants sprinkled amongst empty strings like a magical incantation.
I'd rather see a struct with a builder which has a toString, so this could be written more legibly.

Maybe something like:

out.printf(ResourceRow.builder()
        .groupId(groupId)
        .artifactId(artifactId)
        .verison(version)
        .type(ResourceRow.Type.Resource)
        .path(resourcePath)
        .toString()

[steve-aom-elliott]

Going to add one last update to the actual tests that I forgot, but other than that, should be converted