Vote for 1

Perhaps we can separate the bullet to make the intent of interpretation (1) clear:

• [...] or, is reused by an object that is not nested within o ([intro.object]).
• the initialization of an object that is not nested within o but reuses the storage occupied by o starts ([intro.object]).

Could this be interfered by implicit object creation? (Although implicit object creation can be considered not happening in constant evaluation.)

Edit: perhaps implicit creation should also be considered:

• [...] or, is reused by an object that is not nested within o ([intro.object]).
• the initialization or the lifetime of an object that is not nested within o but reuses the storage occupied by o starts ([intro.object]).

As the opener of the original clang bug, I was surprised to see that it appeared to "work" on gcc. As much as I would have liked for this to be valid because it simplifies some code to avoid a self-move-assignment check, I also couldn't figure out how implementations could actually make this work with things like NRVO, which feels like the far more important optimization to support. So coming at this from a purely pragmatic instead of conceptual angle, it seems like a resolution like the proposed option 1 would be better.

To make sure I understand option 1 fully, this would mean that in new(p) T(x), the expression x can reference *p as usual, but the constructor of T must treat *p in the same it would treat any reference to an object whose lifetime has not begun, correct? So the following would also be ill-formed:

struct s {
    int m;
};

void f() {
    s x{1};
    new(&x) s(x.m);
}

So the following would also be ill-formed

I think you mean would be UB, but yes

The invocation of the allocation function is sequenced before the evaluations of expressions in the new-initializer

(https://timsong-cpp.github.io/cppwp/n4868/expr.new#23.sentence-1)

So by the time the evaluation of x.m starts, x would rebind to the newly-created object.

CWG2721