Котлин - Наследование в выражении объекта

 open class A {
    companion object {
        const val a1 = "some_data_1"
        const val a2 = "some_data_2"
    }
}

class B : A() {
    companion object {
        const val b1 = "some_data_3"
    }
    val a_1 = a1
    val a_2 = a2
}

Я бы, наверное, нырнул немного глубже. Объект в вашем примере является объявлением Object Declaration. Вы должны взглянуть на этот документ, описывающий объявления объектов и выражения объектов.

Вопрос в том, почему вам нужно, чтобы один класс только с константами расширял другой (также содержащий только константы)?
Декларации объектов - это Kotlin, встроенный в Singletons, а BTW потокобезопасны.
Пример:

object DeviceProvider {


    private val _devices = ArrayList<Device>()

    fun getDevices() = _devices as List<Device>

    fun registerDevice(device: Device) {
        _devices.find { it == device } ?: _devices.add(device)
    }
}

Использование:

fun addDevice(){
    ServiceProvider.registerDevice(Device("1234"))
}

Object declarations могут расширять открытые классы и интерфейсы - так что вы можете определить поведение или даже состояние с помощью наследования. Как обычно, вы можете взглянуть на документы Kotlin о наследовании, они исчерпывающие и приятно читаются.
Тем не менее, если мы говорим об общих подходах, определяющих константные значения - тогда отдельный файл является лучшим решением, если, конечно, это значение должно быть привязано к какому-либо конкретному классу. Вот хорошая точка зрения (спасибо Марко за ваш ответ):

В Java вы вынуждены помещать все статические объявления полей и методов в класс, и часто вам даже приходится создавать класс именно для этой цели. Приезжая в Kotlin, многие пользователи ищут эквивалентные средства по привычке и в конечном итоге злоупотребляют сопутствующими объектами.

Kotlin полностью разделяет понятия файла и класса. Вы можете объявить любое количество открытых классов в одном файле. Вы также можете объявить частные функции и переменные верхнего уровня, и они будут доступны только для классов в одном файле. Это отличный способ организовать тесно связанный код и данные.

Kotlin - язык объектно-ориентированного программирования (ООП). Мы можем наследовать объект A от объекта B, для этого нам нужно разрешить наследование класса "A", для этого нам нужно присоединить модификатор open перед классом, чтобы сделать его не финальным.

Для const мы должны использовать объект-компаньон, который является общим для всех экземпляров этого класса.

open class A {
     companion object {
        const val a1 = "some_data_1"
        const val a2 = "some_data_2"
     }
 }

class B : A() {
    companion object {
        const val b1 = "some_data_3"
    }
    val a_1 = a1
    val a_2 = a2
}

Проверьте эту ссылку, чтобы понять наследование

Проверьте эту ссылку, чтобы понять Companion Object

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

interface A {
    companion object {
        const val a1 = "some_data_1"
        const val a2 = "some_data_2"
    }
}

interface B : A {
    companion object {
        const val b1 = "some_data_3"
    }
}

для того чтобы класс был унаследован в Kotlin, он должен быть open например, open class A {} для класса B для расширения класса A должен добавить class B: A() для констант должен быть внутри companion object {}