You're probably aware of this, but @FunctionalInterface is not a type, it's an annotation. All it does is ensure, at compile time, that the annotated element is an interface with a single non-default and non-static method. At the type-system level, it's just an interface like any other, and the lambda syntax is just a shorthand for an anonymous instance of a well-defined type.
Since the lambda syntax is java-compiler magic, you can't access it from Clojure, and the most straightforward option right now is to actually know which type is expected, e.g.:
user=> (-> (doto (java.util.ArrayList.) (.add 1) (.add 2)) (.stream) (.map (reify java.util.function.Function (apply [_ arg] (inc arg)))) (.collect (java.util.stream.Collectors/toList)))
[2 3]
user=>
As neither IFn nor Function are Clojure protocols, I do indeed think you're best bet is a macro to essentially generate the above reify. You can of course do a single macro that reifies to all of the protocols that you need.
I don't think it's realistic to hope that IFn will cover any arbitrary @FunctionalInterface, as that is Java compiler magic. It may, in the future, be extended to cover all of the standard ones in java.util.function, or even all the ones in the standard library, but it's not going to happen until Java 7 support is dropped. I guess the best you could hope for in the short term would be to have IFn changed to a protocol.