Have snowballs actually ever been able to hit players in vanilla?

No. In vanilla Minecraft on a vanilla server, snowballs and other throwables do not hit players.

It's simply occam's razor; if snowballs didn't hit the player in alpha 1.0.5, and don't hit the player in release 1.8.4 (and also all versions after release 1.4.4, as confirmed in MC-3179), and there is no indication in any changelog that the behavior changed, let alone changed twice in between those versions, it stands to reason that such a change did not occur.

There are some server plug-ins that change this behavior, though. Snowball Damage is a Bukkit plugin that does precisely what it says on the tin. Similar plugins with similar functionalities exist. This is likely where the confusion comes. Many, many servers use Bukkit (in 2012, 80% of servers were running Bukkit. More current statistics are unavailable), so many users may have been exposed to such plugins, and are remembering behavior that does not exist in vanilla.

Chances are, whether a snowball will hit another player or not is entirely dependant on if PvP is enabled. Because, after all, if a snowball does indeed hurt someone and cause knockback, then you wouldn't want that affecting other players on non-PvP servers.

According to the decompiled source code of version 1.7.10 (the last version of the code you can get before Mojang began enforcing its will on not wanting the source code released), you can hit another player with a snowball, but it does no damage and causes no knockback.

The EntitySnowball class shows us that Snowballs only apply actual damage to Blazes (the damage value is 0, unless it's a Blaze, in which case its 3):

protected void a(MovingObjectPosition movingobjectposition) {
    if (movingobjectposition.entity != null) {
        byte b0 = 0;

        if (movingobjectposition.entity instanceof EntityBlaze) {
            b0 = 3;
        }

        movingobjectposition.entity.damageEntity(DamageSource.projectile(this, this.getShooter()), (float) b0);
    }
    //[...]
}

The damageEntity routine in the EntityLiving class does various things, like check invulnerability, calculate how much damage reduction a helmet has from falling anvils, checking fire resistance, and other things. Notably, it plays a hurt sound. This sound is played even if a damage value of 0 is given to the function. Also, notably, knockback isn't applied in the damageEntity() function; knockback is handled separately.

The final sticking point is the overridden damageEntity routine in the EntityPlayer class. Due to how overridding works, this method is called first when damaging a player. This method is written a little obtusely.

public boolean damageEntity(DamageSource damagesource, float f) {
    if (this.isInvulnerable()) {
        return false;
    } else {

Obviously, if the player is invulnerable for whatever reason, no damage is applied (and no sound is produced).

        boolean flag = this.server.X() && this.server.getPvP() && "fall".equals(damagesource.translationIndex);

        if (!flag && this.invulnerableTicks > 0 && damagesource != DamageSource.OUT_OF_WORLD) {
            return false;

This extremely confusing set of checks is finding instances when damage wouldn't be applied. Considering that Minecraft actually functions, chances are this "return false" is often passed over successfully.

        } else {
            if (damagesource instanceof EntityDamageSource) {
                Entity entity = damagesource.getEntity();

                if (entity instanceof EntityHuman && !this.a((EntityHuman) entity)) {
                    return false;
                }

This line checks to see if the damage is coming from a Human. The this.a() function checks the server's PvP setting, and then if the other player is a team ally. If the PvP is off, or the other player is an ally, the function returns here and no damage is done nor hurt sound produced. Note, this line checks for the one player punching another (possibly with weapon in hand) and not for projectiles.

                if (entity instanceof EntityArrow) {
                    EntityArrow entityarrow = (EntityArrow) entity;

                    if (entityarrow.shooter instanceof EntityHuman && !this.a((EntityHuman) entityarrow.shooter)) {
                        return false;
                    }
                }

These lines, however, check for projectiles. Or rather, for Arrows, only. As it only checks for only Arrows, other projectiles like Snowballs and Eggs are not included in this check. Thus when throwing a snowball, these lines are not executed.

            }

            return super.damageEntity(damagesource, f);
        }
    }
}

Finally, the function ends by calling the method described above in the EntityLiving class, which applies damage and produces a "hurt" sound. Note that because the Snowball bypasses the Arrow in PvP check, it should "hit" the other player, in that the other player will make a sound and apply invulnerability flashing. However, snowballs do no damage and produce no knockback.

(By extension, Eggs should work the exact same way, as they too pass a 0 to the damageEntity() function).

Yes, throwing a snowball is like throwing an egg. It will hit you, make the sound and animation, and it might even do damage. Snowballs do very little damage, if any, but they do actually hit another player. You could also hit yourself by throwing it straight up in the air and letting it fall onto you