这个解决方案是解决这个问题的银，怎么欣赏都不为过。
先看这个Kotlin文件：

/**
 * credits to https://github.com/Tishka17/gson-flatten for inspiration
 * Author: A$CE
 */

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FIELD)
annotation class Flatten(val path: String)

class FlattenTypeAdapterFactory(
    private val pathDelimiter: String = "."
): TypeAdapterFactory {

    override fun <T: Any?> create(gson: Gson, type: TypeToken<T>): TypeAdapter<T> {
        val delegateAdapter = gson.getDelegateAdapter(this, type)
        val defaultAdapter = gson.getAdapter(JsonElement::class.java)
        val flattenedFieldsCache = buildFlattenedFieldsCache(type.rawType)

        return object: TypeAdapter<T>() {

            @Throws(IOException::class)
            override fun read(reader: JsonReader): T {
                // if this class has no flattened fields, parse it with regular adapter
                if(flattenedFieldsCache.isEmpty())
                    return delegateAdapter.read(reader)
                // read the whole json string into a jsonElement
                val rootElement = defaultAdapter.read(reader)
                // if not a json object (array, string, number, etc.), parse it
                if(!rootElement.isJsonObject)
                    return delegateAdapter.fromJsonTree(rootElement)
                // it's a json object of type T, let's deal with it
                val root = rootElement.asJsonObject
                // parse each field
                for(field in flattenedFieldsCache) {
                    var element: JsonElement? = root
                    // dive down the path to find the right element
                    for(node in field.path) {
                        // can't dive down null elements, break
                        if(element == null) break
                        // reassign element to next node down
                        element = when {
                            element.isJsonObject -> element.asJsonObject[node]
                            element.isJsonArray -> try {
                                element.asJsonArray[node.toInt()]
                            } catch(e: Exception) { // NumberFormatException | IndexOutOfBoundsException
                                null
                            }
                            else -> null
                        }
                    }
                    // lift deep element to root element level
                    root.add(field.name, element)
                    // this keeps nested element un-removed (i suppose for speed)
                }
                // now parse flattened json
                return delegateAdapter.fromJsonTree(root)
            }

            override fun write(out: JsonWriter, value: T) {
                throw UnsupportedOperationException()
            }
        }.nullSafe()
    }

    // build a cache for flattened fields's paths and names (reflection happens only here)
    private fun buildFlattenedFieldsCache(root: Class<*>): Array<FlattenedField> {
        // get all flattened fields of this class
        var clazz: Class<*>? = root
        val flattenedFields = ArrayList<Field>()
        while(clazz != null) {
            clazz.declaredFields.filterTo(flattenedFields) {
                it.isAnnotationPresent(Flatten::class.java)
            }
            clazz = clazz.superclass
        }

        if(flattenedFields.isEmpty()) {
            return emptyArray()
        }
        val delimiter = pathDelimiter
        return Array(flattenedFields.size) { i ->
            val ff = flattenedFields[i]
            val a = ff.getAnnotation(Flatten::class.java)!!
            val nodes = a.path.split(delimiter)
                .filterNot { it.isEmpty() } // ignore multiple or trailing dots
                .toTypedArray()
            FlattenedField(ff.name, nodes)
        }
    }

    private class FlattenedField(val name: String, val path: Array<String>)
}

然后将其添加到Gson，如下所示：

val gson = GsonBuilder()
            .registerTypeAdapterFactory(FlattenTypeAdapterFactory())
            .create()
Retrofit.Builder()
            .baseUrl(baseUrl)
            ...
            .addConverterFactory(GsonConverterFactory.create(gson))
            .build()

使用您的示例，可以如下解析pojo：

// prefer constructor properties
// prefer val over var
// prefer added @SerializedName annotation even to same-name properties:
// to future proof and for easier proguard rule config
data class Restaurant(
    @SerializedName("id") val id: String,
    @SerializedName("name") val name: String,
    @SerializedName("url") val url: String,
    @Flatten("location.city") val city: String,
    @Flatten("location.latitude") val latitude: Double,
    @Flatten("location.longitude") val longitude: Double,
    @Flatten("location.zipcode") val zipcode: String,
    @SerializedName("currency") var currency: String 
)

你甚至可以写一个数组的路径，例如@Flatten("friends.0.name") = get first friend 's name。
但是，请注意，我将TypeAdapter剥离为只读取/使用json对象。如果您也想使用write()来编写json，则可以实现它。
不客气。