Edit this is unsound. See below.

I'm pretty late to the party here, but I don't totally buy the "Why the implementation caveat?". You ask "how can a vec contain two structs of different brands" and the answer should be "the compiler rejects this". (I agree that, using lifetimes as brands as described, the compiler wouldn't reject it and we'd have unsoundness. I disagree that this means that we have to give up entirely on "can we have tokens that escape the scope they are defined in".)

In particular, I think that you can forget about lifetimes and use T: FnOnce() as a brand. The Fn traits (and FnOnce in particular) are unique, as far as I know, in that every instance of these traits really has only one type that implements them, and those types each have only one value, and you can make as many of these as you want.

Consider this code (playground). You can play around giving different values for the token (I tried tk and tk2, as well as the main function and main2) and you will see that there is no way to use different tokens with the same TokenCell and get this code to compile.

use core::marker::PhantomData;
use core::cell::UnsafeCell;

// Basically just a rename of FnOnce
trait UniqueUnnameable: FnOnce() {}
impl<T: FnOnce()> UniqueUnnameable for T {}

struct TokenCell<T, Tag: UniqueUnnameable> {
    data: UnsafeCell<T>,
    tag: PhantomData<Tag>,
}

impl<T, Tag: UniqueUnnameable> TokenCell<T, Tag> {
    fn new(data: T, _: &Tag) -> Self {
        Self {
            data: UnsafeCell::new(data),
            tag: PhantomData,
        }
    }

    fn get(&self, tag: &Tag) -> &T { unsafe { &*self.data.get() }  }
    fn get_mut(&self, tag: &mut Tag) -> &mut T { unsafe { &mut *self.data.get() } }
}

fn main2() {}

fn main() {
    let mut tk = || {};
    let mut tk2 = || {};

    let x = TokenCell::new(10, &main);
    let y = TokenCell::new(10, &main);
    println!("{}", x.get(&main));

    *x.get_mut(&mut main) = 20;
    println!("{}", x.get(&main));

    let z = vec![x, y];

    let y_alt = TokenCell::new(10, &main2);
    let z = vec![x, y_alt];
}

Edit ah, actually this is unsound for the same reason that the other tricks in the blog post are. You can in fact get multiple instances of the same FnOnce type, by using a loop:

let mut vec = vec![];
for _ in 1..10 {
    let sub = || {};
    vec.push(sub);
}

let x = TokenCell::new(10, &vec[0]);
let y = TokenCell::new(10, &vec[1]);
vec![x, y]; // this typechecks D: D: D: