foo.rs

macro_rules! cascade {
    ($(
        if #[cfg($($meta:meta),*)] { $($it:item)* }
    ) else * else {
        $($it2:item)*
    }) => {
        __items! {
            () ;
            $( ( ($($meta),*) ($($it)*) ), )*
            ( () ($($it2)*) ),
        }
    }
}

macro_rules! __items {
    (($($not:meta,)*) ; ) => {};
    (($($not:meta,)*) ; ( ($($m:meta),*) ($($it:item)*) ), $($rest:tt)*) => {
        __apply! { cfg(all($($m,)* not(any($($not),*)))), $($it)* }
        __items! { ($($not,)* $($m,)*) ; $($rest)* }
    }
}

macro_rules! __apply {
    ($m:meta, $($it:item)*) => {
        $(#[$m] $it)*
    }
}

usage.rs

cascade! {                                        
    if #[cfg(feature = "libunwind")] {            
        mod libunwind;                            
        pub use self::libunwind::trace;           
    } else if #[cfg(feature = "unix-backtrace")] {
        mod unix_backtrace;                       
        pub use self::unix_backtrace::trace;      
    } else {                                      
        mod noop;                                 
        pub use self::noop::trace;                
    }                                             
}                                                 

Nice! I'm not gonna comment on that Lispy voodoo, but it seems to work.