https://docs.github.com/en/actions/managing-workflow-runs-and-deployments/managing-workflow-runs/manually-running-a-workflow
https://stackoverflow.com/questions/76363988/github-actions-workflow-dispatch-event-triggers-automatically-on-pull-request

`static_cast` to lvalue suppresses Clang's self-assignment warning.
Add (missing?) EXPECTs to silence Clang's unused-variable warning.
Add an accessor to suppress Clang's unused-private-field warning.
Drive-by rename "empty_base" to "disengaged_base", since the phrase
"empty base" means something different in C++.

Add two new tests: one for `optional<optional<int>&>`, and one
testing that we can construct and assign to `optional<T&>` from
`reference_wrapper<T>` (which should work: since `reference_wrapper<T>`
is implicitly convertible to `T&`, it also should be implicitly
convertible to `optional<T&>`).
These tests are both red before this patch and green afterward.

The new tests are red before the patch and green afterward.

The return type of `emplace` had been wrong; `emplace` returns a
reference to the emplaced value (in this case, the T& reference
that was bound), not `*this`.

The new tests are red before the patch and green afterward.

This test fails with at least one alternative approach to the
constructor overload set (involving =delete'd candidates which
make this overload resolution ambiguous).

The status quo in C++23 is that
    int i;
    auto o = make_optional<int&>(i);
produces an `optional<int>`, not an `optional<int&>`. This would be horribly
confusing to propagate into C++26 — users would naturally expect to receive
an `optional<int&>`. Worse,
    auto o = make_optional<int&>(std::ref(i));
actually *would* give you an `optional<int&>`, because it would use a different
overload of `make_optional`! So, we propose to add a "Mandates" element to
`make_optional` that requires its explicit template argument (if any) to be
a non-array object type.
This breaks the "status quo" example at the top of this comment (requiring
an Annex C entry); but it successfully prevents the pitfalls.

Thanks to Tomasz Kamiński for the template-programming trick, which matches
the technique used in https://eel.is/c++draft/out.ptr .