javascript multiple inheritance code review
First of all, I responded to the post in c.l.js, and this content in part reiterates the comments there.

My first thought is that you should look at some of the available mixin libraries.  There are many mixin techniques available.  And on top of that, there are many interesting approaches layered on top of them.  Peter Michaux published one recently on applying mixins to constructor functions.  Angus Croll published one on creating functions out of mixins, and together with Dan Webb he also presented this technique at the recent Fluent Conference.  I published a rough draft of an article on a still different approach to mixins.

I don't understand the reason for your complex syntactic structure.
You assign your ObjectExt variable to the result of an immediately
invoked function expression (IIFE).  That IIFE involves defining a
constructor function, attaching the inherit function to its
prototype`, and then constructing and returning an instance of that
constructor:

 var ObjectExt = (function () {
     var ObjectExt = function () { };
     ObjectExt.prototype.inherit = function (Parent, Child) {
         // content here
     };
     return new ObjectExt();
 })();


I don't see that any of that serves any purpose over the much simpler
version here:

 var ObjectExt = {inherit: function (Parent, Child) {
     // content here
 };


Can you give any reason for the existence of this constructor
function, the IIFE, the prototype, etc?  It seems to be plain
overhead, and serves only to obfuscate your code.

One other minor point is that you probably should declare your key
variable once in the top of the inherit function. 

But the main issue is that you add properties to the parent.prototype object.  In this code:

if(Child.uber === undefined)    {
    Child.uber = Parent.prototype;               // (1)
} else {
    for(var key in Parent.prototype)    {
       Child.uber[key] = Parent.prototype[key];  // (2)
    }
}


in the line marked (1), you create the Child.uber property as reference to the Parent.prototype.  So any properties you add when you come through the if-block again and hit (2) will be added to the orignial prototype object.  This is a pretty fundamental flaw.  An example would be the following:

var Pet = function(name) {this.name = name;}
Pet.prototype.speak = function(){
    console.log(this.name + " speaks.");
};
var WalkingAnimal = function() {};
WalkingAnimal.prototype.walk = function() {
    console.log(this.name + " is walking.");
};
var SwimmingAnimal = function() {};
SwimmingAnimal.prototype.swim = function() {
    console.log(this.name + " is swimming.");
};
var Dog = function(name) {this.name = name;};
WebbaseUtility.ObjectExt.inherit(Pet, Dog);
WebbaseUtility.ObjectExt.inherit(WalkingAnimal, Dog);

var ClownFish = function(name) {this.name = name;};
WebbaseUtility.ObjectExt.inherit(Pet, ClownFish);
WebbaseUtility.ObjectExt.inherit(SwimmingAnimal, ClownFish);

var rover = new Dog("Rover");
var nemo = new ClownFish("Nemo");
rover.walk();  // "Rover is walking";
nemo.swim();   // "Nemo is swimming";
nemo.walk();   // "Nemo is walking";   // WTF?


This is a fairly fundamental design flaw.  I think you need to rethink your approach to this problem.

Cheers,

-- Scott