File: src/main/java/com/fasterxml/jackson/databind/deser/impl/CreatorCollector.java
Issue: Problem with bogus conflict between single-arg-String vs CharSequence constructor
Although it is good idea to allow recognizing CharSequence as almost like an alias for String, this can cause problems for classes like StringBuilder that have separate constructors for both.
This actually throws a bogus exception for 2.5.0, due to introduction of ability to recognize CharSequence.

Buggy code:
protected void verifyNonDup(AnnotatedWithParams newOne, int typeIndex, boolean explicit)
{
    final int mask = (1 << typeIndex);
    _hasNonDefaultCreator = true;
    AnnotatedWithParams oldOne = _creators[typeIndex];
    // already had an explicitly marked one?
    if (oldOne != null) {

        if ((_explicitCreators & mask) != 0) { // already had explicitly annotated, leave as-is
            // but skip, if new one not annotated
            if (!explicit) {
                return;
            }
            // both explicit: verify
            // otherwise only verify if neither explicitly annotated.
        }

        // one more thing: ok to override in sub-class
        if (oldOne.getClass() == newOne.getClass()) {
            // [databind#667]: avoid one particular class of bogus problems

                throw new IllegalArgumentException("Conflicting "+TYPE_DESCS[typeIndex]
                        +" creators: already had explicitly marked "+oldOne+", encountered "+newOne);
            // otherwise, which one to choose?
                // new type more generic, use old
            // new type more specific, use it
        }
    }
    if (explicit) {
        _explicitCreators |= mask;
    }
    _creators[typeIndex] = _fixAccess(newOne);
}

Fixed code:
protected void verifyNonDup(AnnotatedWithParams newOne, int typeIndex, boolean explicit)
{
    final int mask = (1 << typeIndex);
    _hasNonDefaultCreator = true;
    AnnotatedWithParams oldOne = _creators[typeIndex];
    // already had an explicitly marked one?
    if (oldOne != null) {
        boolean verify;

        if ((_explicitCreators & mask) != 0) { // already had explicitly annotated, leave as-is
            // but skip, if new one not annotated
            if (!explicit) {
                return;
            }
            // both explicit: verify
            verify = true;
        } else {
            // otherwise only verify if neither explicitly annotated.
            verify = !explicit;
        }

        // one more thing: ok to override in sub-class
        if (verify && (oldOne.getClass() == newOne.getClass())) {
            // [databind#667]: avoid one particular class of bogus problems
            Class<?> oldType = oldOne.getRawParameterType(0);
            Class<?> newType = newOne.getRawParameterType(0);

            if (oldType == newType) {
                throw new IllegalArgumentException("Conflicting "+TYPE_DESCS[typeIndex]
                        +" creators: already had explicitly marked "+oldOne+", encountered "+newOne);
            }
            // otherwise, which one to choose?
            if (newType.isAssignableFrom(oldType)) {
                // new type more generic, use old
                return;
            }
            // new type more specific, use it
        }
    }
    if (explicit) {
        _explicitCreators |= mask;
    }
    _creators[typeIndex] = _fixAccess(newOne);
}