Q:

Prototype-binding on re-evaluated anonymous constructor retroactive to original instantiated objects

This is more of a theory question than a how-to question.   I was working on a project in which objects can "differentiate" into several different types, so I decided to explore some of Javascript's dynamic features, but there's one thing that has me really confused:
OriginalConstructor = function() {this.value = 42;}
originalInstance = new OriginalConstructor();
ModifiedConstructor = eval(originalInstance.constructor);
ModifiedConstructor.prototype.addedFunction = function(x) {return this.value + x;}
modifiedInstance = new ModifiedConstructor();
document.write("modified: " + modifiedInstance.addedFunction(10));
document.write("<br>original: " + originalInstance.addedFunction(20));

Why is addedFunction bound to originalInstance, even though ModifiedConstructor was copied through eval()?   Surely these two constructors can't have the same reference, can they? 
Is there a way to modify an object (or future instances) without affecting other objects already instantiated from the same constructor?   I know there are other ways to approach this, but I want to understand Javascript at a deeper level.   Thanks for any insights you can offer. 
@Felix Kling:
Thanks for the quick, clear and complete answer.   For some reason, I thought the constructor property was a string that could be parsed by eval(), so now I understand why this didn't work.   I still don't fully understand prototypal inheritance, but at least now I know what I need to study.   Thank you! 
EDIT:
I get it now.   Prototypal inheritance seems pretty weird if you're coming from a background in classical OOP, but it's conceptually simpler and easier to understand, AND it's actually more powerful in some ways.   If you want to learn more about Javascript's prototypal inheritance, I highly recommend these articles:
http://javascript.crockford.com/prototypal.html
http://www.laktek.com/2011/02/02/understanding-prototypical-inheritance-in-javascript/
http://blog.vjeux.com/2011/javascript/how-prototypal-inheritance-really-works.html
http://howtonode.org/prototypical-inheritance
Also, if you need this kind of flexibility, you may want to consider using an "entity system", which would offer several advantages as an alternative to a complex hierarchy of inheritance.   Most articles about entity systems focus on game development, but I think this architecture could be useful for other applications as well.   It's a very foreign concept to OOP programmers, so set aside everything you know about OOP and think more in terms of relational database design.   Check it out:
http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/
http://t-machine.org/index.php/2007/09/03/entity-systems-are-the-future-of-mmog-development-part-1/

A:

ModifiedConstructor is not a copy of OriginalConstructor, it is one and the same function. 
The first instruction in eval's algorithm is:

If Type(x) is not String, return x.

i.e. you simply get back what you pass in.  OriginalConstructor === ModifiedConstructor yields true. 

Is there a way to modify an object (or future instances) without affecting other objects already instantiated from the same constructor? 

You can, through prototypal inheritance:
ModifiedConstructor = function() {
    OriginalConstructor.apply(this, arguments);
};

ModifiedConstructor.prototype = Object.create(OriginalConstructor.prototype);
ModifiedConstructor.prototype.constructor = ModifiedConstructor;

Now you can add functions to ModifiedConstructor.prototype without affecting instances created by OriginalConstructor. 
If you only want to prevent already created instances from being extended, you could just overwrite OriginalConstructor.prototype, but is not a clean solution and will also break instanceOf for the existing instances.