Add support for version catalog entries in fg.deobf (#976)

This support includes bundles.

```groovy
dependencies {
    implementation fg.deobf(libs.examplemod)
    runtimeOnly fg.deobf(libs.bundles.exampledeps)
}
```

Author: Jonathing

src/userdev/java/net/minecraftforge/gradle/userdev/DependencyManagementExtension.java

@@ -6,7 +6,10 @@
 package net.minecraftforge.gradle.userdev;
 
 import groovy.lang.Closure;
+import groovy.lang.DelegatesTo;
 import groovy.lang.GroovyObjectSupport;
+import groovy.transform.stc.ClosureParams;
+import groovy.transform.stc.SimpleType;
 import groovy.util.Node;
 import groovy.util.NodeList;
 import net.minecraftforge.gradle.common.util.BaseRepo;
@@ -18,11 +21,18 @@
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.ExternalModuleDependency;
+import org.gradle.api.artifacts.ExternalModuleDependencyBundle;
+import org.gradle.api.artifacts.MinimalExternalModuleDependency;
 import org.gradle.api.artifacts.repositories.ArtifactRepository;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.provider.ProviderConvertible;
 import org.gradle.api.publish.maven.MavenPublication;
 import org.gradle.api.publish.tasks.GenerateModuleMetadata;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
@@ -53,16 +63,81 @@ public ArtifactRepository getRepository() {
 
     @SuppressWarnings("unused")
     public Dependency deobf(Object dependency) {
+        //noinspection DataFlowIssue -- null closure is allowed here
         return deobf(dependency, null);
     }
 
-    public Dependency deobf(Object dependency, Closure<?> configure) {
+    public Dependency deobf(
+        Object dependency,
+        @DelegatesTo(Dependency.class)
+        @ClosureParams(value = SimpleType.class, options = "org.gradle.api.artifacts.Dependency")
+        Closure<?> configure
+    ) {
         Dependency baseDependency = project.getDependencies().create(dependency, configure);
-        project.getConfigurations().getByName(UserDevPlugin.OBF).getDependencies().add(baseDependency);
+        project.getDependencies().add(UserDevPlugin.OBF, baseDependency);
 
         return remapper.remap(baseDependency);
     }
 
+    @SuppressWarnings("unused")
+    public <T> Provider<?> deobf(Provider<T> dependency) {
+        //noinspection DataFlowIssue -- null closure is allowed here
+        return deobf(dependency, null);
+    }
+
+    public <T> Provider<?> deobf(
+        Provider<T> dependency,
+        @DelegatesTo(ExternalModuleDependency.class)
+        @ClosureParams(value = SimpleType.class, options = "org.gradle.api.artifacts.ExternalModuleDependency")
+        Closure<?> configure
+    ) {
+        project.getDependencies().addProvider(UserDevPlugin.OBF, dependency, baseDependency -> {
+            //noinspection ConstantValue -- null closure is allowed here
+            if (configure != null)
+                configure.call(baseDependency);
+        });
+
+        // Checking for presence after DependencyHandler#addProvider so Gradle can throw its usual errors as needed
+        if (!dependency.isPresent()) return dependency;
+
+        if (dependency.get() instanceof ExternalModuleDependencyBundle) {
+            // this provider MUST return ExternalModuleDependencyBundle
+            // The only way to coerce the type of it is to use a property, since we can set the type manually on creation.
+            // ProviderInternal#getType uses the generic argument to determine what type it is.
+            // Provider#map and #flatMap do NOT preserve the resultant type, which fucks with adding bundles to configurations.
+            return project.getObjects().property(ExternalModuleDependencyBundle.class).value(project.provider(() -> {
+                ExternalModuleDependencyBundle newBundle = new RemappedExternalModuleDependencyBundle();
+                for (MinimalExternalModuleDependency d : (ExternalModuleDependencyBundle) dependency.get()) {
+                    //noinspection ConstantValue -- null closure is allowed here
+                    if (configure != null)
+                        configure.call(d);
+
+                    newBundle.add((MinimalExternalModuleDependency) remapper.remap(d));
+                }
+                return newBundle;
+            }));
+        } else {
+            return dependency.map(d -> remapper.remap(project.getDependencies().create(d, configure)));
+        }
+    }
+
+    @SuppressWarnings("unused")
+    public <T> Provider<?> deobf(ProviderConvertible<T> dependency) {
+        //noinspection DataFlowIssue -- null closure is allowed here
+        return deobf(dependency, null);
+    }
+
+    public <T> Provider<?> deobf(
+        ProviderConvertible<T> dependency,
+        @DelegatesTo(ExternalModuleDependency.class)
+        @ClosureParams(value = SimpleType.class, options = "org.gradle.api.artifacts.ExternalModuleDependency")
+        Closure<?> configure
+    ) {
+        return deobf(dependency.asProvider(), configure);
+    }
+
+    private static class RemappedExternalModuleDependencyBundle extends ArrayList<MinimalExternalModuleDependency> implements ExternalModuleDependencyBundle { }
+
     @SuppressWarnings({"ConstantConditions", "unchecked"})
     public MavenPublication component(MavenPublication mavenPublication) {
         project.getTasks().withType(GenerateModuleMetadata.class).forEach(generateModuleMetadata -> generateModuleMetadata.setEnabled(false));