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);
  }
}

Just

new ObjectMapper().writeValueAsString(myResult);

The type of the list won't be lost due to type erasure in the same way it would be in the first example.

Note that for vanilla serialization of a list or generic list, it's not necessary to specify the list component types, as demonstrated in the example in the original question. All three of the following example serializations represent the List<Bar> with the exact same JSON.

import java.util.ArrayList;
import java.util.List;

import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
import org.codehaus.jackson.annotate.JsonMethod;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ObjectWriter;

public class JacksonFoo
{
  public static void main(String[] args) throws Exception
  {
    Baz baz = new Baz("BAZ", 42);
    Zab zab = new Zab("ZAB", true);
    List<Bar> bars = new ArrayList<Bar>();
    bars.add(baz);
    bars.add(zab);

    ObjectMapper mapper = new ObjectMapper().setVisibility(JsonMethod.FIELD, Visibility.ANY);

    String json1 = mapper.writeValueAsString(bars);
    System.out.println(json1);
    // output:
    // [{"name":"BAZ","size":42},{"name":"ZAB","hungry":true}]

    Foo foo = new Foo(bars);

    String json2 = mapper.writeValueAsString(foo);
    System.out.println(json2);
    // output:
    // {"bars":[{"name":"BAZ","size":42},{"name":"ZAB","hungry":true}]}

    mapper = new ObjectMapper().setVisibility(JsonMethod.FIELD, Visibility.ANY);
    ObjectWriter typedWriter = mapper.writerWithType(mapper.getTypeFactory().constructCollectionType(List.class, Bar.class));

    String json3 = typedWriter.writeValueAsString(bars);
    System.out.println(json3);
    // output:
    // [{"name":"BAZ","size":42},{"name":"ZAB","hungry":true}]
  }
}

class Foo
{
  List<Bar> bars;
  Foo(List<Bar> b) {bars = b;}
}

abstract class Bar
{
  String name;
  Bar(String n) {name = n;}
}

class Baz extends Bar
{
  int size;
  Baz(String n, int s) {super(n); size = s;}
}

class Zab extends Bar
{
  boolean hungry;
  Zab(String n, boolean h) {super(n); hungry = h;}
}

A typed writer is useful when serializing with additional type information. Note how the json1 and json3 outputs below differ.

import java.util.ArrayList;
import java.util.List;

import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
import org.codehaus.jackson.annotate.JsonMethod;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ObjectMapper.DefaultTyping;
import org.codehaus.jackson.map.ObjectWriter;

public class JacksonFoo
{
  public static void main(String[] args) throws Exception
  {
    Baz baz = new Baz("BAZ", 42);
    Zab zab = new Zab("ZAB", true);
    List<Bar> bars = new ArrayList<Bar>();
    bars.add(baz);
    bars.add(zab);

    ObjectMapper mapper = new ObjectMapper().setVisibility(JsonMethod.FIELD, Visibility.ANY);
    mapper.enableDefaultTypingAsProperty(DefaultTyping.OBJECT_AND_NON_CONCRETE, "type");

    String json1 = mapper.writeValueAsString(bars);
    System.out.println(json1);
    // output:
    // [
    //   {"type":"com.stackoverflow.q8416904.Baz","name":"BAZ","size":42},
    //   {"type":"com.stackoverflow.q8416904.Zab","name":"ZAB","hungry":true}
    // ]

    Foo foo = new Foo(bars);

    String json2 = mapper.writeValueAsString(foo);
    System.out.println(json2);
    // output:
    // {
    //   "bars":
    //   [
    //     "java.util.ArrayList",
    //     [
    //       {"type":"com.stackoverflow.q8416904.Baz","name":"BAZ","size":42},
    //       {"type":"com.stackoverflow.q8416904.Zab","name":"ZAB","hungry":true}
    //     ]
    //   ]
    // }

    mapper = new ObjectMapper().setVisibility(JsonMethod.FIELD, Visibility.ANY);
    mapper.enableDefaultTypingAsProperty(DefaultTyping.OBJECT_AND_NON_CONCRETE, "type");
    ObjectWriter typedWriter = mapper.writerWithType(mapper.getTypeFactory().constructCollectionType(List.class, Bar.class));

    String json3 = typedWriter.writeValueAsString(bars);
    System.out.println(json3);
    // output:
    // [
    //   "java.util.ArrayList",
    //   [
    //     {"type":"com.stackoverflow.q8416904.Baz","name":"BAZ","size":42},
    //     {"type":"com.stackoverflow.q8416904.Zab","name":"ZAB","hungry":true}
    //   ]
    // ]
  }
}