There's no built-in way to do this. You'll have to write your own JsonSerializer. Something like

class ModelSerializer extends JsonSerializer<List<Model>> {

    @Override
    public void serialize(List<Model> value, JsonGenerator jgen,
            SerializerProvider provider) throws IOException {
        jgen.writeStartArray();
        for (Model model : value) {
            jgen.writeStartObject();
            jgen.writeObjectField("model", model);
            jgen.writeEndObject();    
        }
        jgen.writeEndArray();
    }

}

and then annotate the models field so that it uses it

@JsonSerialize(using = ModelSerializer.class)
private List<Model> models;

This would serialize as

{
    "status": "success",
    "models": [
        {
            "model": {
                "id": 1,
                "color": "red"
            }
        },
        {
            "model": {
                "id": 2,
                "color": "green"
            }
        }
    ]
}

If you're both serializing and deserializing this, you'll need a custom deserializer as well.

You cannot do that with JsonTypeInfo. You need a custom serializer that checks the instance of each items in the list and serialize them accordingly.

First, create a wrapper of your list.

@JsonSerialize(using = MyCustomListSerializer.class)
public class ListWrapper {
    private List<Object> list;

    public ListWrapper(){
        list = new ArrayList<>();
    }

    public void add(Object o){
        list.add(o);
    }

    public Object get(int i){
        return list.get(i);
    }

    public List<Object> list(){
        return list;
    }
}

Then the custom serializer

public class MyCustomListSerializer extends JsonSerializer<ListWrapper> {
    @Override
    public void serialize(ListWrapper value, JsonGenerator jgen, SerializerProvider provider)
      throws IOException, JsonProcessingException {

        jgen.writeStartArray();

        for(Object o : value.list()){
            jgen.writeStartObject();
            if(o instanceof Integer){
                jgen.writeNumberField("java.lang.Integer", (int) o);
            }else if(o instanceof Double){ //by default, floated values are represented by double
                jgen.writeNumberField("java.lang.Float", (double) o);
            }else if(o instanceof Color){
                jgen.writeStringField("myPackage.Color", ((Color)o).toString());
            }else if(o instanceof Date){
                jgen.writeStringField("java.util.Date", o.toString());
            }else{ //default to String
                jgen.writeStringField("java.lang.String", o.toString());
            }
            jgen.writeEndObject();
        }

        jgen.writeEndArray();
    }
}

A Jackson ObjectMapper is relatively expensive to create, but once created it can be re-used for many conversions very cheaply. Your benchmark is flawed as it includes the ObjectMapper creation time in the measurement. A better benchmark would create one ObjectMapper up front, then perform several hundred or thousand conversions using the same mapper and calculate the average time per conversion. If you do this you'll see much more respectable numbers.

An ObjectMapper instance is thread-safe once fully configured, so it would be safe to do the following (exception handling code ignored for clarity)

public class X {
  private static final ObjectMapper MAPPER = new ObjectMapper();

  public static <T> String listToString(List<T> list) {
    if(list == null) return null;
    else return MAPPER.writeValueAsString(list);
  }
}