Как избежать неопределенного поведения сalign_storage и полиморфизмом

Не уверен в точной семантике того, требуется ли reinterpret_cast для работы с типами базового класса, но вы всегда можете это сделать,

typename std::aligned_storage<sizeof(Derived), alignof(Derived)>::type storage;

auto derived_ptr = new (&storage) Derived{};
auto base_ptr = static_cast<Base*>(derived_ptr);

std::cout << base_ptr->forward() << std::endl;

Также зачем использовать auto&& со ссылкой base в вашем коде?

Если вы знаете только тип базового класса в своем коде, рассмотрите возможность использования простого трейта в абстракции для aligned_storage

template <typename Type>
struct TypeAwareAlignedStorage {
    using value_type = Type;
    using type = std::aligned_storage_t<sizeof(Type), alignof(Type)>;
};

и теперь вы можете использовать объект хранилища, чтобы получить тип, который он представляет

template <typename StorageType>
void cast_to_base(StorageType& storage) {
    using DerivedType = std::decay_t<StorageType>::value_type;
    auto& derived_ref = *(reinterpret_cast<DerivedType*>(&storage));
    Base& base_ref = derived_ref;

    base_ref.forward();
}

Если вы хотите, чтобы это работало с идеальной пересылкой, используйте простую черту пересылки

namespace detail {
    template <typename TypeToMatch, typename Type>
    struct MatchReferenceImpl;
    template <typename TypeToMatch, typename Type>
    struct MatchReferenceImpl<TypeToMatch&, Type> {
        using type = Type&;
    };
    template <typename TypeToMatch, typename Type>
    struct MatchReferenceImpl<const TypeToMatch&, Type> {
        using type = const Type&;
    };
    template <typename TypeToMatch, typename Type>
    struct MatchReferenceImpl<TypeToMatch&&, Type> {
        using type = Type&&;
    };
    template <typename TypeToMatch, typename Type>
    struct MatchReferenceImpl<const TypeToMatch&&, Type> {
        using type = const Type&&;
    };
}

template <typename TypeToMatch, typename Type>
struct MatchReference {
    using type = typename detail::MatchReferenceImpl<TypeToMatch, Type>::type;
};

template <typename StorageType>
void cast_to_base(StorageType&& storage) {
    using DerivedType = std::decay_t<StorageType>::value_type;
    auto& derived_ref = *(reinterpret_cast<DerivedType*>(&storage));
    typename MatchReference<StorageType&&, Base>::type base_ref = derived_ref;

    std::forward<decltype(base_ref)>(base_ref).forward();
}

Если вы используете стирание типов для создания производных типов классов, которые затем добавляете в однородный контейнер, вы можете сделать что-то вроде этого

struct Base {
public:
    virtual ~Base() = default;
    virtual int forward() = 0;
};

/**
 * An abstract base mixin that forces definition of a type erasure utility
 */
template <typename Base>
struct GetBasePtr {
public:
    Base* get_base_ptr() = 0;
};

template <DerivedType>
class DerivedWrapper : public GetBasePtr<Base> {
public:
    // assert that the derived type is actually a derived type
    static_assert(std::is_base_of<Base, std::decay_t<DerivedType>>::value, "");

    // forward the instance to the internal storage
    template <typename T>
    DerivedWrapper(T&& storage_in)  { 
        new (&this->storage) DerivedType{std::forward<T>(storage_in)};
    }

    Base* get_base_ptr() override {
        return reinterpret_cast<DerivedType*>(&this->storage);
    }

private:
    std::aligned_storage_t<sizeof(DerivedType), alignof(DerivedType)> storage;
};

// the homogenous container, global for explanation purposes
std::unordered_map<IdType, std::unique_ptr<GetBasePtr<Base>>> homogenous_container;

template <typename DerivedType>
void add_to_homogenous_collection(IdType id, DerivedType&& object) {
    using ToBeErased = DerivedWrapper<std::decay_t<DerivedType>>;
    auto ptr = std::unique_ptr<GetBasePtr<Base>>{
        std::make_unique<ToBeErased>(std::forward<DerivedType>(object))};
    homogenous_container.insert(std::make_pair(id, std::move(ptr)));
}

// and then
homogenous_container[id]->get_base_ptr()->forward();

Вы можете просто сделать

auto* derived = new (&storage) Derived{};
Base* base = derived;

So no reinterpret_cast.

В «простом» примере, который у вас есть, поскольку вы выполняете преобразование из производного в базовое, будет работать либо static_cast, либо dynamic_cast.

Более сложный вариант использования закончится плачевно, потому что базовые значения базового указателя и производного указателя на один и тот же объект могут не совпадать. Это может работать сегодня, но не работать завтра:

1. reinterpret_cast плохо работает с наследованием, особенно с множественным наследованием. Если вы когда-нибудь наследуете от нескольких баз, а первый базовый класс имеет размер (или не имеет размера, если пустая базовая оптимизация не выполняется), reinterpret_cast ко второму базовому классу из несвязанного типа не будет применяться смещение.
2. Перегрузка плохо сочетается с переопределением. Шаблонные классы не должны иметь виртуальных методов. Шаблонные классы с виртуальными методами не следует использовать со слишком большим выводом типов.
3. Неопределенное поведение лежит в основе способа, которым MI задается в C++, и неизбежно, потому что вы пытаетесь получить что-то (во время компиляции), что вы преднамеренно стерли (во время компиляции). Просто отбросьте каждое ключевое слово virtual из этого класса и реализуйте все с помощью шаблонов, и все будет проще и правильнее.
4. Вы уверены, что объекты вашего производного класса могут уместиться в пределах 16 байт? Вам, наверное, нужно немного static_assert.
5. Если вы готовы мириться с потерей производительности, вызванной виртуальными функциями, зачем заботиться о выравнивании?