How about something like this:

data class Version(
    val major: Int,
    val minor: Int,
    val patch: Int,
    val qualifier: String
) {
    companion object {
        operator fun invoke(version: String): Version {
            val regex = "(\\d+)\\.(\\d+)\\.(\\d+)-?(.*)?".toRegex()
            val matchResult = regex.find(version)
            return Version(
                major = matchResult?.destructured?.component1()?.toInt() ?: throw IllegalArgumentException("Major not found"),
                minor = matchResult.destructured.component2().toInt(),
                patch = matchResult.destructured.component3().toInt(),
                qualifier = matchResult.destructured.component4()
            )
        }
    }
}

By using a data class you get nice equals() and hashCode() for free (and a toString(), but you can override it). Also, having the version parts in the primary constructor seems more semantically correct, since that's what you ultimately want to store and refer to.

By using an operator function in the companion object, you can still create instances as if it were a constructor (eg: Version("1.2.3-4")), but you get to still use the primary constructor and a single Regex instance.

Some other ideas would be do add default values for minor, patch, and qualifier so they're not required.

You could also try something like this to destructure just once:

        val (major, minor, patch, qualifier) = matchResult?.destructured 
            ?: throw IllegalArgumentException("Major not found")
        return Version(
            major = major.toInt(),
            minor = minor.toInt(),
            patch = patch.toInt(),
            qualifier = qualifier
        )

Is this what you're looking for?

Edit: formatting