Fix koin#2402: explicit @KoinApplication modules override discovered @configuration

Runtime Koin is last-wins, so the order of module loading determines
which binding wins when multiple modules define the same type.

Before: explicit `@KoinApplication(modules = [...])` loaded first, then
auto-discovered `@Configuration` dependency modules. That meant a
dependency's default implementation silently overrode the app's custom
override, which is the opposite of typical intent ("the app customises
the libraries, not the other way round").

After: discovered modules load first, explicit list last. Within each
half, user-declared order is preserved — so
`@KoinApplication(modules = [A, B, C])` loads A, then B, then C, with
C winning over A and B as the declared order implies. Each entry's
`@Module(includes = [...])` chain stays grouped with that entry.

Dedupe is now against explicit, so a module re-listed in the explicit
`modules = [...]` keeps its explicit position rather than being merged
to the discovered half — user's explicit listing always wins
positionally.

Regression test (`testData/box/startkoin/explicit_modules_override_configuration.kt`):
a @configuration core module provides DefaultFeature, the app's
@KoinApplication(modules=[AppModule]) provides AppFeature as override,
runtime asserts `get<Feature>().name() == "app-override"`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: arnaudgiuliani

koin-compiler-plugin/src/org/koin/compiler/plugin/ir/KoinStartTransformer.kt

@@ -281,11 +281,24 @@ class KoinStartTransformer(
         // Discover modules filtered by configuration labels
         val discoveredModules = discoverConfigurationModules(configurationLabels)
 
-        // Combine explicit modules with auto-discovered @Configuration modules
-        val allModules = (explicitModules + discoveredModules)
-            .distinctBy { it.fqNameWhenAvailable }
-
-        return allModules
+        // Koin is last-wins at runtime, so load order determines override precedence.
+        //
+        // Rule (#2402): auto-discovered @Configuration modules first, explicit
+        // @KoinApplication(modules = [...]) last. That way an app module listing a
+        // feature override wins over the discovered dependency, which matches the
+        // typical intent of "the app customises the libraries, not the other way round".
+        //
+        // Within each half we preserve the user's declaration order so they can still
+        // control fine-grained order via an explicit list (modules = [A, B, C] loads
+        // A then B then C, and C wins among those three).
+        //
+        // Dedupe discovered AGAINST explicit (not the other way round) so a module the
+        // user re-declares in the explicit list keeps its explicit position — and
+        // therefore its explicit override priority.
+        val explicitFqNames = explicitModules.mapNotNull { it.fqNameWhenAvailable }.toSet()
+        val uniqueDiscovered = discoveredModules.filterNot { it.fqNameWhenAvailable in explicitFqNames }
+
+        return uniqueDiscovered + explicitModules
     }
 
     /**

koin-compiler-plugin/test-gen/org/jetbrains/kotlin/compiler/plugin/template/runners/JvmBoxTestGenerated.java

@@ -462,6 +462,12 @@ public void testConfiguration_discovery() {
       runTest("koin-compiler-plugin/testData/box/startkoin/configuration_discovery.kt");
     }
 
+    @Test
+    @TestMetadata("explicit_modules_override_configuration.kt")
+    public void testExplicit_modules_override_configuration() {
+      runTest("koin-compiler-plugin/testData/box/startkoin/explicit_modules_override_configuration.kt");
+    }
+
     @Test
     @TestMetadata("koin_application.kt")
     public void testKoin_application() {