What's wrong with just writing:

int main()
{
    X ignore;
    foo(ignore);

    return 0;
}

What benefit is gained by adding a wrapper around the unused argument?

As for your wrapper presented, what does it do? It appears to be an elaborate way to put a T inside another struct, except it prevents calling the destructor. I wonder why you would want to do this, and furthermore observe that in your own example this causes a memory leak as the std::string is not freed.

Your enable_if cases prevent it from calling the constructor if it's trivially copyable. I'm not sure that's the right case for noting that the default constructor doesn't do anything interesting (that's not copying it), and for types like primitive int skipping the constructor is contrary to your use of {} in the invocation.

Update

After seeing your comment

I was just looking for a "cleaner" way to write it without having to the declare the variable beforehand.

I'd like to make a couple of observations.

simplify your solution

The reason why you can't write foo(X{}) is because there is a specific rule that prevents binding a non-const rvalue to an lvalue reference. This is to prevent accidents where a temporary, perhaps from an automatic conversion, is passed which makes it not function as an "out" parameter.

The operational part of your solution is the operator T&(). Nothing about your buffer and placement new has any bearing on it! Having a base class with different cases... that's getting off in the weeds.

Here is my improved version of your idea:

template<typename T>
class ignorer {
    T dummy;
public:
    constexpr operator T& () noexcept
       {  return dummy;  }
};

I'm guessing your work to avoid construction and destruction is because there is no need to zero out dummy if it's a primitive type like an int. This class does that naturally. (But, the use of creating an anonymous temporary using Name{} will cause it to be zero initialized. I think you can suppress that by declaring a defaulted default constructor, at least for some versions of C++. Normally we expect zero initialization for primitives when you use {} so I would leave that behavior in to prevent surprises.)

a different approach

You have an rvalue and want to pass it to a parameter that wants an lvalue reference. This is very similar to the case where you have an lvalue and want to pass it to a parameter that wants an rvalue reference. That is, you just want to change the value category.

The latter is done with std::move, and it's implemented as nothing more than a cast. The function template std::forward is also a cast, and will produce either an lvalue or rvalue reference.

So, why not do the same thing?

If you wrote the opposite of move, you would still need to create the temporary using the normal syntax. This would look like:

foo(lvalue(X{}));

which has the advantage that you can give constructor arguments in the normal way, or nominate any temporary such as the result of another expression. That can be useful for "in/out" parameters where you don't care about the "out". E.g. lvalue(complex(2,5)). It's also clear what you are doing and easy to read.

If you want to avoid the extra {} you still need to specify the type somewhere. Make it a function that takes a default argument, and then you can optionally write it as lvalue<T>() instead.