My immediate thought is that you are either making your project way too complex, or you are in way over your head. By the time you start making projects like that, you should have a solid grasp on what works for your team.

Hi I am going to answer some of your questions, not all because I don't have all the issues you have.

This is how I structure my multi language projects. I build my projects on Windows and on Linux.

Binaries (all my compiled output ends up here. Note for cpp I also create a msc/gnu folder to store os specific binaries)

~/bin/
~/bin/cpp   (all compiled libraries, shared objects, and executables go here, sometimes in their own sub folders)
~/bin/csharp  (all compiled dlls go here)
~/bin/py3   (all eggs ans pyd's go here)
~/bin/jar    (all jars go here)

Build

~/build/makefile    (my solution make file goes here, it builds all my languages.  You could put an ant/maven project here... but I rock it old school :P)

Source Code (all my source code goes here)

~/code/cpp/<projname>/subdirs..     (I always use the projname here so my include paths match my namespaces)
~/code/csharp/... various solutions files
~/code/java/... various java projects/packages
~/code/python3/<eggname>/  ... here I create a folder for each egg that I want to create

Externals (most projects have external dependencies, be it other repository's, external library dependencies, or resources)

~/externs/makefile      (a makefile that links or junctions to external repos or libraries )
~/externs/_template.config.mk   (a template for the config settings)
~/externs/config.mk    (config file local to this environments required external dependencies - this file is not checked into the repo)
~/externs/postgres9   --> /usr/lib/postgres9/include    (this would be a link created by my makefile to point to a dependency)

Generated Code

~/genes/...     (various code generation files go here, the either generate into my ~/code folders or locally in this folder)

Release/Packages (any final complete packages built from the the ~/bin folder most build end up here)

~/releases/<end package>.zip
~/releases/<end package>.debug.zip

Testing (finally all my unit testing ends up here)

~/testing/  ...   (I use the python unittest module to create a common start point that wraps unittests the other languages)
~/testing/cpp
~/testing/csharp
~/testing/java
~/testing/py

The build steps for my project are:

1. Check out repo
2. Configure the config.mk (copy _template.config.mk to config.mk and edit) in the externs folder (only have to do this once)
3. gmake the makefile in the externs folder (only have to do this once)
4. gmake the makefile in the build folder

Finally in regards to your question about building specific modules only.. this is what I do.

I generate a makefile for every component for each language. Then then I generate a makefile that build these sub components as groups.

Basically I have makefiles that build "projects/components" and makefiles that collectively run other makefiles that act like "solutions".

For example, if I want to compile all the java code in my project I simply go to my build folder and type:

~/build> gmake java

You could achieve the same thing with ant files or maven however (which is something I do at my job... because a lot people are afraid of make files for some reason).

Read up on fhs, then go in your own direction

What in the world are you building?

And please keep us updated.

This is ambitious regardless of your skill level. Good luck.