How to auto-detect and polyfill std::expected on GCC 11 using tl::expected

/home/uli/Tether/include/tether/io/TetherIOClient.hpp:33:10: fatal error: expected: No such file or directory
   33 | #include <expected>
      |          ^~~~~~~~~~
compilation terminated.

git submodule add https://github.com/TartanLlama/expected.git dependencies/expected
cd dependencies/expected
git checkout v1.3.1
cd ../..
git add dependencies/expected .gitmodules

#pragma once
#include <tl/expected.hpp>
#include <type_traits>
#include <utility>

namespace std {
    using tl::expected;

    // NOTE: We cannot simply do `using tl::unexpected;` because GCC < 12's
    // <exception> header already declares `void std::unexpected()` — the
    // deprecated C++03 unexpected-handler function. A using-declaration cannot
    // override an existing function declaration in the same namespace, so
    // `std::unexpected(arg)` would resolve to the no-arg function and fail.
    //
    // Instead we define a function template that overloads it. When called with
    // an argument (the only way C++23 code uses std::unexpected), overload
    // resolution picks this template over the deprecated void unexpected().
    template <class E>
    auto unexpected(E&& e) {
        return tl::unexpected<std::decay_t<E>>(std::forward<E>(e));
    }
} // namespace std

/usr/include/c++/11/exception:95:8: note: declared here
   95 |   void unexpected() __attribute__ ((__noreturn__));
      |        ^~~~~~~~~~
TetherIOClient.cpp:696:40: error: too many arguments to function 'void std::unexpected()'
  696 |     if (!result) return std::unexpected(result.error());
      |                         ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~

cmake_minimum_required(VERSION 3.16)
project(MyProject VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(CheckIncludeFileCXX)
set(CMAKE_REQUIRED_FLAGS "-std=c++23")
check_include_file_cxx("expected" HAVE_NATIVE_STD_EXPECTED)
unset(CMAKE_REQUIRED_FLAGS)

if(NOT HAVE_NATIVE_STD_EXPECTED)
    message(STATUS "Native <expected> not available; using tl::expected shim.")

    # Validate submodule
    set(EXPECTED_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/expected")
    if(NOT EXISTS "${EXPECTED_PATH}/include/tl/expected.hpp")
        message(FATAL_ERROR
            "expected submodule missing. Run: git submodule update --init --recursive")
    endif()

    # Shim must be searched BEFORE system paths so #include <expected> finds it
    include_directories(BEFORE
        "${CMAKE_CURRENT_SOURCE_DIR}/include/yourproject/expected_shim")
    include_directories("${EXPECTED_PATH}/include")
else()
    message(STATUS "Native <expected> available; using it directly.")
endif()

#include <expected>
#include <iostream>
#include <string>

struct Error { int code; std::string msg; };

std::expected<int, Error> divide(int a, int b) {
    if (b == 0) {
        return std::unexpected(Error{1, "division by zero"});
    }
    return a / b;
}

int main() {
    auto result = divide(10, 2);
    if (result) {
        std::cout << *result << '\n';   // 5
    }

    auto err = divide(10, 0);
    if (!err) {
        std::cerr << err.error().msg << '\n';
    }
    return 0;
}