One is the first number. Until there is one of something there is no point to counting at all. Zero is a regression from one and only significant for the lack of that something which we started counting at 1.

But there absolutely is a point in setting out to count something when it turns out there is zero of that thing. If you don't know how many of something there is, but you know that this information is important, you will want to go out and count. If it's really important, then you will likely want to keep records of the count every time you perform it. This is, of course, very important in commerce.

Oops, I was wrong. A count is a quantity.

This is numbering being talked about. Guy finishes a marathon in first place, he would be the zeroth runner and one runner has finished. Most people would intuitively like those numbers to line up.

Of course, when you build the natural numbers on a computer and use those as indices to arrays, it makes sense that the first index is zero. So the first (common usage) element would then naturally be called the zeroth element. This, of course, gives you the problem that array.size == x means that array.last_index == x - 1 and all the off by one errors that entails.

Sure, but I don't think anyone's complaining about how you would assign race completion position labels in a programming language. Surely you would do something like this:

    // Start the position at one, because that's how we
    // assign number labels to finishers in a race.
    let position = 1

    // Create a callback that will assign a label to
    // each competitor when that competitor finishes
    // the race.
    let assignLabel = (competitor) => {
      competitor.label = position
      position = position + 1
    }

    // Begin the race, and pass it a callback that will
    // be run each time a competitor finishes the race
    // (in the order they finish).
    race.begin(assignLabel)

Note that this "label" really is just a label. It happens to be an integer here, but we could also use a library that outputs English strings like "first", "second", "third", etc. This debate is focused more on how elements in an ordered collection are accessed.

Your logic is missing a temporal element check.

Before any runners have completed the race, there are 0 runners in the set of runners that have completed the race (empty set/null set).

As soon as the first runner crosses the finish line 1 runner has finished the race, increasing the counter by one increment and it is customary to assign them the designation of the upper end of the unit range rather than the lower number. Thus, they are the First (1st) runner to have completed the race.

We count rooms the same way probably out of a similar convention, the first room on a floor is numbered 1, rather than 0, because it is more useful to annotate the end of the range than the start. It makes a lot of math easier too. If there are 10 rooms on a floor and 10 guests, there are 0 rooms free.

Of course, a count and an index aren't really the same thing.