what in the world do you need 14 include files for

1. ctypes.h - (int16, int32, uint16, uint32, etc)
okay this first one isn't really needed but I don't trust compiler writers to not change type sizes on me.
also lets code be more portable to/from other platforms
2. globals.h - defines all of the global variables that are used throughout the entire program. Since there's no pointers or dynamic allocation. The only way to make functions reusable is to have typedef structures and static instances. Also I'll point out that array implementation inside of structures is somewhere between flaky and broken.

3. drive.c - generic implementation of a robot drive. Provides multiple drive modes: Heading/Distance, Heading/Speed, Speed/Turn Rate, Manual, etc. Uses a 2 wheeled kinematic equations so that you can specify driving by in/sec and degree/sec instead of % motor power.

also implements odometry (inverse kinematics) to keep track of the position and orientation of the robot
using the encoders.

4. actuator.c - implements control over robot actuators. implements code that track robot joint orientation (actual position)

5. sensors.c - implements a task that continuously monitors all the sensors connected to the robot and updates the global
variables as needed.

6. advjoystickdriver.c - implements all the important things that the default driver leaves out

7. fuzzy.c - generic implementation of a fuzzy logic controller

8. behavior.c - generic implementation of a subsumption architecture behavior module: defines the target/desired state of drive and actuators.

9. robot.c - provides robot specific implementation of the main control loop:
Sensors determine actual state of robot -> behavior determines desired state of robot -> drive/actuator control makes the actual state == desired state.

10. manual.c - connects the joystick input to behaviour module for robot control during teleop

11. auto.c - connects the autonomous code to behavior module for robot control during autonomous

12. param.c - loads calibration data and autonomous parameters from a file

13. menu.c - provides a user interface for selecting autonomous parameters and selecting debug screens

14. kalman.c - provides a generic implementation of a kalman filter to correct the cheap LEGO sensors

15. proto.c - provides a driver to connect to the HTPB since ROBOTC doesn't include this built in.

16. simple_drive.c - provides the callback functions for the behavior module

17. simple_drive_sa.c - Python script generated, specific implementation of subsumption architecture for behavior module.

18. arm_ctrl.c - Python script generated, specific implementation of fuzzy logic controller for arm control

19. drv_ang_ctrl.c - Python script generated, specific implementation of fuzzy logic controller for heading/angle control

20. drv_pos_ctrl.c - Python script generated, specific implementation of fuzzy logic controller for distance/speed control

21. fuzzy_ctrl.c - provides a task the runs/updates all the fuzzy controllers at a specific rate

I'm not trying to be a pest or confrontational...but are you serious?

I've got 20+ files and I really haven't done anything remotely complicated with autonomous (no neural networks, bayesian learning or SLAM, ...yet)

Just to justify that I'm not as totally crazy as you claim I am... I've listed the ones I'm currently using and explain what each one is for.

<snip snip>

So thats how I use more than 14 files in a single program. Sure I can combine this all into one file, but that's not the point.

RobotC is for writing programs for real robots isn't it? Its being promoted as more than just for toys. FTC is being promoted as being more of a "real" robot challenge.

I would bet any major academic robot project uses this many files (or probably a whole lot more)

How many files do you think the mars rover uses? or the predator? I know where not in that league, but you seriously never "thought" a programmer might reasonably want more than 14 files.