Ccomando que pare o jogo ao digitar um nível inválido

Para isso você teria de interromper a função usando o comando return. Não obstante, seu código pode ser reestruturado para não precisar disso. Segue um exemplo de uma versão refatorada.

# Arquivo makefile
CC=clang++
CXXFLAGS=-Wall -std=c++2a -O3
SRC=$(wildcard *.cpp)
OBJ=$(SRC:.cpp=.o)
EXE=jogo

all: $(EXE)

$(EXE): $(OBJ)
    $(CC) $^ -o $@ $(CXXFLAGS)

%.o: %.cpp
    $(CC) -o $@ -c $< $(CXXFLAGS)

.PHONY: clean cleanAll

clean:
    @rm *.o

cleanAll: clean
    @rm jogo

// Arquivo main.cpp

#include <ctime>
#include <iostream>

#include "Game.h"

int main() {
    srand(time(NULL));

    std::cout << "************************************" << std::endl;
    std::cout << "* Bem-vindo ao jogo da adivinhacao *" << std::endl;
    std::cout << "* ***********************************" << std::endl;

    std::cout << "Escolha a sua dificuldade: " << std::endl;
    std::cout << "Facil (F), Medio (M) ou Dificil (D)." << std::endl;

    while (true) {
        char mode;
        std::cin >> mode;

        if (Game::dictionary.contains(mode)) {
            auto game = Game{
                    []() -> int {
                        int guess;
                        std::cin >> guess;
                        return guess;
                    },

                    [](const std::string &s) { std::cout << s << std::endl; },

                    Game::dictionary.at(mode)
            };

            return game.start();
        } else
            std::cout << "Digite um nivel valido." << std::endl;
    }
}

// Arquivo Game.h

#ifndef GAME_H
#define GAME_H

#include <map>
#include <functional>

class Game {
public:
    template<typename T>
    using Input = const std::function<T(void)> &;

    using Output = const std::function<void(const std::string &)> &;

    enum class Mode {
        EASY = 15, MEDIUM = 10, HARD = 5
    };

    enum class Outcome {
        PLAYING, VICTORY, DEFEAT
    };

    explicit Game(Input<int> in, Output out, Game::Mode mode) : in{in}, out{out}, mode{mode} {}

    ~Game() = default;

    int start(Game::Outcome outcome = Game::Outcome::PLAYING);

    static const std::map<char, Mode> dictionary;

private:
    Outcome update(int);

    void hint(int) const;

    [[nodiscard]] int onPlay() const;

    void onVictory() const;

    void onDefeat() const;

    Input<int> in;
    Output out;
    const Mode mode;
    int counter = 1;
    double points = 1000.0;
    const int secret = abs(std::rand()) % 100 + 1; // NOLINT(cert-msc50-cpp)
};

#endif

#include "Game.h"

#include <sstream>

const std::map<char, Game::Mode> Game::dictionary = std::map<char, Game::Mode>{ // NOLINT(cert-err58-cpp)
        {'F', Mode::EASY},
        {'M', Mode::MEDIUM},
        {'D', Mode::HARD}
};

int Game::start(Game::Outcome outcome) {
    if (outcome != Game::Outcome::PLAYING) {
        if (outcome == Game::Outcome::VICTORY)
            onVictory();
        else
            onDefeat();
        return 0;
    } else
        return start(update(onPlay()));
}

Game::Outcome Game::update(int guess) {
    if (guess == secret) {
        return Outcome::VICTORY;
    } else if (counter < static_cast<int>(mode)) {
        hint(guess);

        counter++;
        points -= abs(secret - guess) / 2.0;

        return Outcome::PLAYING;
    } else
        return Outcome::DEFEAT;
}

void Game::hint(int guess) const {
    auto ss = std::stringstream{};

    ss << guess
       << " é "
       << ((guess > secret) ? "maior" : "menor")
       << " que o número secreto"
       << std::endl;

    out(ss.str());
}

int Game::onPlay() const {
    auto ss = std::stringstream{};

    ss << "Tentativa: "
       << counter
       << "."
       << std::endl
       << "Qual o seu chute? "
       << std::endl;

    out(ss.str());

    return in();
}

void Game::onVictory() const {
    auto ss = std::stringstream{};

    ss.precision(2);

    ss << "Você ganhou."
       << std::endl
       << "Sua pontuação foi de "
       << std::fixed
       << points
       << std::endl;

    out(ss.str());
}

void Game::onDefeat() const {
    auto ss = std::stringstream{};

    ss << "Você perdeu, o número secreto era "
       << secret
       << std::endl;

    out(ss.str());
}