For this kind of mapping, you may be inspired by Arabic, German or Italian. They convert a string to a numeric key (makeLookupKey) containing multiple grammemes, and they map the key to a string. This mapping is initialized in the constructor instead of at runtime.

Is the concern the runtime size increase (static constexpr)? If yes, I can remove the static (creating these arrays is cheap).
Otherwise the current approach looks simpler. I will look into refactoring this code as I add more cases, potentially implementing Arabic like approach.

WDYT?

It was to make it more scalable, but this is fine too.

What do you think of this?

static bool isConsonant(char16_t ch) {
    return morphun::lang::StringFilterUtil::CYRILLIC_SCRIPT().contains(ch) && !morphun::dictionary::PhraseProperties::DEFAULT_VOWELS_START().contains(ch);
}

enum class Syllables {
    ONE_SYLLABLE,
    TWO_SYLLABLES,
    MULTI_SYLLABLES,
};

Syllables countSyllables(const ::std::u16string& word) {
    int32_t total = 0;
    if (word.length() > 2) {
        std::u16string lowercase;
        morphun::util::StringUtils::lowercase(&lowercase, word, ::morphun::util::LocaleUtils::SERBIAN());
        size_t startIndex = 0;
        size_t nextR;
        const auto stringLengthWithVowelSuffix = lowercase.length() - 1; // Always enough room for a suffix letter
        while ((nextR = lowercase.find(u'р', startIndex)) != std::string::npos && nextR < stringLengthWithVowelSuffix) {
            ++total; // +1 for r
            if (isConsonant(lowercase[nextR + 1]) && (nextR == 0 || isConsonant(lowercase[nextR - 1]))) {
                ++total;
            }
            startIndex = nextR + 1;
        }
    }

    if (total == 1) {
        return Syllables::ONE_SYLLABLE;
    } else if (total == 2) {
        return Syllables::TWO_SYLLABLES;
    } else {
        return Syllables::MULTI_SYLLABLES;
    }
}

Your code skips vowels (only counts Rs). I like the isConsonant, and I added isVowel function and used it in the code.
It looks simpler now.

PTAL

In this scenario, you should check enableInflectionGuess before using the rules.

You have a lot of fully fleshed out constraints. Most of the other languages only change specific grammemes. Sometimes you only specify the case, number or gender. The other tests usually specify less. The other languages usually default to noun. These tests are currently fine, but common usage starts from any surface form (ideally a unique surface form), and then you modify just the relevant grammemes.

It was to make it more scalable, but this is fine too.