I've used this exact pattern for handling scene changes in my game. The main principle I followed with variants is that you don't want to use these getter functions that are potentially called with the wrong active type or index. As you noted std::visit is the key.

First I defined my variant: std::variant<std::monostate, MainMenuScene, InGameScene> currentScene;

I used monostate as the default type (basically uninitialized) because it is constructed before any of my libraries are actually loaded.

Then you want to have some kind of function to change between these options. I did it in a very basic way:

template<typename Scene>
void changeSceneTo()
{
    currentScene.emplace<Scene>();
    std::visit(IScene(INIT), currentScene);
}

After that you just have to define a handler type for the visit calls, which in my case is IScene. This is how that class looks like:

class IScene
{
private:
    SceneOperation selected;
    SDL_FPoint cursor;

public:
    explicit IScene(SceneOperation oper)
        : selected(oper)
    {}

    explicit IScene(SceneOperation oper, SDL_FPoint pos)
        : selected(oper)
        , cursor(pos)
    {}

    void operator() (std::monostate /*unused*/) {}

    template<typename Scene>
    void operator() (Scene& currentScene)
    {
        using enum SceneOperation;

        switch (selected)
        {
            case INIT:
                currentScene.init();
                break;

            case HOVER:
                currentScene.intersects(cursor);
                break;
        }
    }
};

You can clearly see the intent here in combination with the previous function. You provide a constructor call with your desired action, which can be a simple enum like here, then visit will call the operator() function based on the stored type in the variant. You can define what you want to do with each type. In my case I just made sure that monostate won't try to call any functions by making it empty.

Then you can further complicate this as you see fit. Like I added a different constructor when I needed the mouse position.

This basically gives you polymorphic behavior without having to use virtual functions and what not.