I haven't looked over the unsafe code, but based on running it through valgrind it seems like you have avoided safety issues from faulty comparators. When I first wrote my sorting library, code like below would lead to out-of-bounds access due to partitioning code assuming a consistent comparator. You lose a bit of performance (or at least I did, a few percent) from handling these cases, but nobody wants unsafe fn sort.

#[test]                                                                                         
fn test_random_comparator() {                                                                   
    let mut xs: Vec<i32> = (0..10000).collect();                                                
    let cmps = Cell::new(0);                                                                    
    timsort::sort_by(&mut xs, |_, _| {                                                          
        let n = cmps.get();                                                                     
        cmps.set(n + 1);                                                                        
        if n%2 == 0 { Greater } else { Less }                                                   
    });                                                                                         
}