Your points are good, but I think you're focusing on the idea of "one module is the application" related to CGI::Application too much.

The way I use CGI::Application is I write a central module, "SuperClass.pm" that has shared functions for all my other modules that make up an entire web application. I then use this SuperClass in all my application modules.

Example:
Here's SuperClass, the shared base class for all my modules.

Package SuperClass.pm
use DBI;
use whatever_else_you_want;
use base 'CGI::Application';

sub cgiapp_init{
   my $self=shift;
   ## initialize variables, stuff them into params to allow
   ## all other modules to inherit common functions. For
   ## instance, I'll set up my DBI connection, user
   ## authentication,  HTML::Template object, etc. all in 
   ## here. Then every object from here on down can access
   ## them.
   }
[download]

package UserManager;
use base 'SuperClass';

sub setup{
   my $self=shift;
   my $q = $self->query(); #Get CGI.pm object
   $self->start_mode('print');
   $self->mode_param('rm');

   $self->run_modes(
      'login'=>'login',
      'delete'=>'delete',
      'list'=>'list'
      #More run modes here.
   );
}

sub login{
   #do stuff here according to what's inherited from 
   #SuperClass- For instance, use the HTML::Template
   #that SuperClass specifies. This greatly increases
   #reusability.
}
[download]

I then build all my other application modules split logically into appropriately named .pms', but all still sharing the same core. e.g. there's a UserManager.pm, Survey.pm, RSS.pm, Search.pm, etc.

I don't think of developing with CGI::Application like I need to stuff everything into one module at all, put your shared functions into a "SuperClass" and then use that as the API that you develop the rest of your application modules around.

Though I'm pretty much a "lone-wolfer," this methodology seems to lend itself very nicely to working with a team: You articulate to them what is provided by SuperClass, and they code around it. If you need to figure out what someone wrote, you just look at their run modes and you can very easily figure out what's happening. Seems pretty scalable to me.

Hope this helps! I really suggest that anyone looking to make webapps look closely at CGI::Application. It enforces good coding standards, uses the excellent HTML::Template module to great effect, and is very flexible and lightweight.