Why prepend a class property?

Firstly, you are correct in being able to use your suggestion. Personally I wouldn't, which I will provide an example for that may or may not be a reason to always use the underscore convention, but still I think is a good use case.

So to answer the first question, question you had. "Why not use a different name like ownerName?" Well, you most certainly can, although she used a different name too (i.e. _owner). So using ownerName doesn't better solve using _owner since neither option is equal to owner. Both are just alternatives.

As you or she stated, you cannot use the same name, which is due to circular referencing. Calling this.owner calls the getter get owner() { ... } which returns this.owner which calls the getter get owner() { ... }, see where I am headed? :] it just won't end.

The other course you took that had the info about prepending is correct. Conventionally in JavaScript, developers use the underscore to signify a "private" property or method, since there currently is no support for accessors. This lets other developers know, on your team, or consumers of your code, to not fiddle with properties/methods. For the most part, other developers will respect that and only use the "public" properties, that do not contain an underscore. So if you were to call it ownerName it would show up as such and not be read by others as "private". This can even effect yourself as you come back to the code later in time and not remember that you shouldn't mess with it.

My reasoning for keeping the property name the same with the underscore is for clarity and mapping of the two properties. Keeping the underscore will tell myself and others, that "assume this doesn't exist outside of the class". Also I can safely assume that the getter owner is related to _owner. So if you were to later extend owner to return an object instead of just a string, you can store more specific information under a different "private" property name, just as _ownerName. Example of what I mean:

// Current implementation (using _ownerName)
class Pet {
    ...
    get owner() {
        return this._ownerName
    }

    set owner(value) {
        this._ownerName = value;
    }
    ...
}

const myPet = new Pet(/* values here */)
myPet.owner = "Some Guy"
myPet.owner // "Some Guy"

Now we want a more complex owner because we have people for some reason:

class Person {
    constructor(firstName, lastName, age) {
        this.name = { firstName, lastName }
        this.age = age
    }
}

class Pet {
    ...
    get owner() {
        return this._ownerName
    }
    set owner(value) {
        this._ownerName = value
    }
    ...
}
const myPet = new Pet(/* values here */)
myPet.owner = new Person("Some", "Guy", 25)
myPet.owner // Person { name: { firstName: "Some", lastName: "Guy" }, age: 25 }

Now _ownerName doesn't make sense contextually, since it is storing an Owner Person, so now would you change the variable name everywhere throughout the class to make it make sense? Or maybe just update some documentation about what owner returns? I'd go with the latter

Hope that helps? Again, there is no "it must be this way" reasoning and nothing really stopping you from doing things the way you suggest other than convention and foresight. In development, not always, but most of the time, it is best to follow conventions and practices, since you will likely use code written by others, whom may follow the conventions, and have others use or work within the codebase you are working on.