Since AbstractStringBuilder is not a public class, short of asking the developers why they wrote it, one can only speculate...
Speculation
Note that StringBuffer,
A thread-safe, mutable sequence of characters.
was added in 1.0. StringBuilder's Javadoc reads
A mutable sequence of characters. This class provides an API compatible with StringBuffer, but with no guarantee of synchronization. This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread (as is generally the case). Where possible, it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.
(emphasis mine) and was added in 1.5. The idea is that this class is an improvement upon StringBuffer in most cases, but is overall very similar in functionality (can replace each other). As noted by @immibis and @MadProgrammer in the comments, the idea of inheritance saves a lot of trouble in cases where you want similar functionality.
I found one simple example in the method append(String). In StringBuilder, it is
@Override public StringBuilder append(String str) { super.append(str); return this; }
In StringBuffer it is
@Override public synchronized StringBuffer append(String str) { toStringCache = null; super.append(str); return this; }
and in AbstractStringBuilder it is
public AbstractStringBuilder append(String str) { if (str == null) return appendNull(); int len = str.length(); ensureCapacityInternal(count + len); str.getChars(0, len, value, count); count += len; return this; }
What we see is that the only difference between the thread-safe and not thread-safe versions is some cache control (toStringCache), but they both call the same method in their superclass, hence reusing code through inheritance.
Analogy
Think of it as if you are the one writing code. You create a class dog which includes the anatomical structure of a dog (ears, tail, 4 legs...) and methods related to its action, like bark. After 5 years you want to create a class cat to represent a cat. Would you start from scratch? No, you would create an abstract class FourLeggedAnimal with the structure of ears, tail, 4 legs etc., and with the method makeSound. You will then extends this class and use all those similarities in both subclasses, overriding when necessary (bark and meow).
Asking
What's the point of creating the useless wrapper StringBuilder?
will be the same as someone asking you
What's the point of creating the useless wrapper Cat?
StringBuffercould extend it, too.StringBuffercame first, and then they wanted to addStringBuilder. So they probably moved all the code fromStringBufferintoAbstractStringBuilder, then made it extend it, and then madeStringBuilderextend it too.