I'm guessing that it is higher than 90% of the users use the IDE.
No progress in changing the build methodology. If anything the current
methodology has become further entrenched when Paul's additions to
make it aware of dates/times to prevent needless re-compiles and some
new code which has rules for how to handle header file name collisions.
It is a bit ironic that the very early IDE built makefiles and then called make.
If only it stayed on that path....
As an alternative kludge for using the IDE, you can drop multiple libraries into
the same library directory.
This works because the IDE does not care where a header file lives.
So for example, you could bundle up multiple Arduino "libraries" and put them
all in a single library directory.
library foo is independent but foobar depends on foo.
library foo, and foobar could both be put into the "foo" directory
and then shipped to the user as what appears to be a single library.
If the user sketch references any header file in that directory, the IDE will compile
all the modules in root of the directory and will add that directory to the include path.
It will then link against the compiled modules in the library.
This allows the sketch to use either foo or foobar and when foobar is included
by the sketch if any foo headers are needed by the foobar headers,
the foo headers will also be found since they reside in the same directory as foobar.
So if you want to create multiple sub libraries from your library you can as long
as you put all them in the same library directory and the sketch references at
least one of the headers in the directory.
It is a horrible hack/kludge but it is about all you can do given the way the
IDE is coded.
However it does allow you to have and ship a more complex collection
of interdependent libraries as a single bundle, which does have some advantages
for less technical users.
The only catch is that all the modules in the library directory will be built and linked
against vs just the modules that are used.
If you are careful with your coding the unused code will removed by the linker
so the final result is that you only get the code that is used.
While this kludge can work great for a collection of sublibraries that don't need
other external libraries,
it doesn't work when referencing other arduino libraries like say Wire.
In that case the sketch will still have to include a header from that library to
tell the dumb IDE that the library is being used to get the library directory to be
added to the include path and to build and link the library code.
The tricky part is handling interrupts. If you have code that uses ISRs,
You have to play some games with some weak attributes to ensure that the ISRs don't get linked in and then drag in lots of unused code.
This is because the way the compiler tools currently work, ISR code is always dragged in.