wip: Improve resolution logic

Adding a new dependency of an already existing type should reset all
dependencies that depend on that class/interface/type so they can be
re-resolved with the new dependency.

lib/src/main/kotlin/io/nexure/capsule/Capsule.kt

@@ -79,7 +79,12 @@ private constructor(
             vararg parents: Capsule,
             config: Configuration.() -> Unit
         ): Capsule {
-            val dependencies: LinkedList<Dependency> = parents.map { it.dependencies }.flatten().let { LinkedList(it) }
+            val dependencies: LinkedList<Dependency> = parents
+                .map { it.dependencies }
+                .flatten()
+                .map { it.reset() }
+                .let { LinkedList(it) }
+
             val parentsPriority: Int = parents.minOfOrNull { it.priority } ?: DEFAULT_PRIORITY
             val priority: Int = parentsPriority - 1
             val moduleConfig = Configuration(priority, dependencies).apply(config)
@@ -92,18 +97,20 @@ internal class Dependency
 private constructor(
     val key: String,
     val priority: Int,
-    constructor: () -> Any,
+    private val constructor: () -> Any,
 ): Comparable<Dependency> {
-    private val instance: LazyValue<Any> = LazyValue(constructor)
+    private val instance: Lazy<Any> = lazy(initializer = constructor)
 
     fun getInstance(): Any {
         return try {
-            instance()
+            instance.value
         } catch (e: Exception) {
             throw DependencyException(key, e)
         }
     }
 
+    fun reset(): Dependency = Dependency(key, priority, constructor)
+
     override fun toString(): String = key
 
     override fun compareTo(other: Dependency): Int = this.priority.compareTo(other.priority)