Here is what I see a problem is: ASDF only resolves dependencies on a system by system basis. The cross-system link is that if system B depends on system A we can avoid loading A if it has already been loaded. If an identical source file happens to be in both B and A that isn't recognized, but also doesn't have consequence - the functions in it are redefined.
Resolving the maven dependencies in java needs to be a globally done across ASDF systems. If one ASDF system A depends on log4j version 2.1 or higher and another B depends on 2.9, and the range of versions is 2.1-2.12 then if A is loaded first there is no way to satisfy the second dependence in a predictable way. If you choose the highest available version A can take it is too high for B. If you choose the lowest A can choose it is too low for B.
Java systems manage this because they are built from a single root POM file. That POM can include other POMs which have additional dependencies, but solving the full set of dependencies consistently is done at one fell swoop. While there may be seeming conflicts, there are mechanisms for making choices - the including POM can specify a version for a dependency an included POM specifies - "managed dependencies" and exclusions. There's also a fundamental difference in that what maven is doing with the dependencies is collecting them into a classpath, and then the process is run with the classpath. Because of this there aren't load-time side effects, as one has with lisp. There are static initializers that depend on classes in other jars, but these are never called for until the process is started.
I'm honestly not sure how to handle this generally, or specifically with ASDF. One piece could be having a persistent registry of components (as opposed to just systems). Then, instead of just reloading a component that happens to be the same, we could detect whether the requested component's version is compatible with what was previously loaded. Another piece could be to distinguish between dependencies needed for loading the system versus runtime, and then handling the planning for a system and all the systems it depends on at once, instead of one planning one system at a time, with the default being load-time independence. That default would be analogous to the need to make exceptions for within file by use eval-when :compile-toplevel.
Hope this helps. Perhaps both these capabilities are already easily available. My use of ASDF doesn't extend far enough to know, and I haven't spent a lot of time studying ASDF.
Any ideas would certainly be welcome.
Alan