I'm rethinking what I thought was a need to start with &dyn Foo<T>. I think that on the side of the interface that knows T, I will have a reference to something that is impl Foo<T>, and will have to go from that to &dyn Bar on the other side of the interface.
In fact, I think I could always wrap the impl Foo<T> in a repr transparent struct so that I can (unsafe, but safe because of the transparent repr) cast from a &impl Foo<T> to a reference to that wrapper struct. Then I can impl Bar for the wrapper struct.
The 20K foot view of what I'm trying to accomplish is: I am not yet using Rust dynamic libs, but I know I will eventually want to. I want to prepare by constructing an interface that passes &dyn Trait and primitive types only. However, one side of the interface wants to use a generic trait that is ultimately parameterized by types known to that same side of the interface (Foo and T in Foo<T> in my example), while the other side of the interface wants a concrete trait (Bar) connected to that. In some cases (different Foos and Bars in each case), I will need the concrete trait to impl the generic one, and in other cases, vice versa. Obviously, all impls are on the side that knows T.