Passing Object's Instance in Javascript

Here's an issue:

for (i = 0;/*...*/)

I would suggest you spend a little more time in JS.
It does look a lot like C / Java / C# / PHP, etc...

The problem, however, is that JS does not have any notion of block scope*.

* until ES6, that is

It only deals with function scope.

That is, a variable has the same reference through the whole function where it's defined (via var).

If a variable is not defined via var, the function goes up to its parent to find the value of the variable, and up from there, and up from there, until it hits window.<varname>.

You might actually be modifying window.i in your class' instance.

function Bill ( ) {
    var bill = this,
        i = 0;

    for (i=0; /* ... */) { /*...*/ }
}

That said, you might do to spend time getting to know JS.
Most of what you've written looks absolutely fine, in English, as well.

I might break it down a little further:

function Bill () {
    var bill = this;
    extend(bill, {
        total : 0,
        items : [],
        addOrder : function (order) {
            var match = bill.findOrder(order.name);
            if (!match) { bill.items.push(order);  }
            else { bill.updateOrder(match, order); }
            bill.updateTotal();
        },
        findOrder : function (name) {
            var matches = bill.items.filter(function (order) {
                return order.name === name;
            });
            return matches[0];
        },
        updateOrder : function (current, updated) {
            /* I don't know if you want to replace the old order, or add to it...  */
            /* so I'm "replacing" it, instead of increasing quantity, like you did */
            current.quantity = updated.quantity;
            current.price    = updated.price;
        },
        updateTotal : function () {
            bill.total = bill.items
                .map(function (order) { return order.getSubtotal(); })
                .reduce(function (tally, price) { return tally + price; }, 0);
        }
    });
}

var bill = new Bill();
bill.addOrder(new Order(/*...*/));

I'm doing a few things differently, here.
First, extend isn't a "built-in" function; there are a lot of implementations, in all sorts of libraries, but basically, it just saves me from writing bill.x = x; bill.y = y; bill.z = z;..., and use an object, instead.

Next, I'm using var bill = this;
and bill.method = function () { bill.total = /*...*/; };
instead of this.method = function () { };, because once you go two levels down, in functions, this no longer means the object you think it does.

this.method = function () {
    this.async(function (response) {
        // unless you change it yourself, `this` probably means `window`
        this.value = response; // oops
    });
};

// instead, try
var thing = this;
thing.method = function () {
    thing.async(function (response) {
        thing.value = response;
    });
};

Of course, you can always mix and match, as long as you know how far down you can go (one level)...
...but that means you really, really need to care about using this a whole lot.

var thing = this;
this.method = function () {
    this.async(function (val) {
        thing.value = val;
    });
};

Much more confusing than just referring to the instance by a variable, rather than combining the two.

There are dozens of ways of doing this; some look very class-like, others might be 100% functional, and in ES6, you might just use classes altogether.

But there are some ideas, and some reasons behind doing them that way (especially if you don't know where the differences are in JS vs the other C-looking languages).

I don't think you're stretching JS too thin, at all.