Funções como strlen(), count() e in_array() são alguns exemplos que se beneficiam bastante dessa otimização.

Só de curiosidade, fiz um teste rápido usando a ferramenta phpbench para medir os tempos.

O teste foi bem simples, só chamei strlen e in_array com e sem a barra, passando os mesmos argumentos:

class TimeConsumerBench {
    private $s;
    private $v;
    public function __construct() {
        $this->s = 'kjfasdsjfdsaklfjaksjfklasdjfjasdfjasdlfjasjfasldçjfasd';
        $this->v = range(1, 1000); // array com os números de 1 a 1000
    }

    public function benchStrlenSemBarra() {
        strlen($this->s);
    }
    public function benchStrlenComBarra() {
        \strlen($this->s);
    }

    public function benchInArraySemBarra() {
        in_array(2000, $this->v);
    }
    public function benchInArrayComBarra() {
        \in_array(2000, $this->v);
    }
}

Para montar todo o teste, basta seguir o tutorial básico da documentação (apenas adaptei dali).

Fiz o teste rodando 10 iterações para cada função, sendo que a cada iteração ela é executada 1 milhão de vezes. A linha de comando usada foi:

./vendor/bin/phpbench run tests/Benchmark --report=aggregate --iterations=10 --revs=1000000

Os testes foram feitos com PHP 8.1.2, phpbench 1.2.14, em uma máquina com Ubuntu 22.04.3, processador 11th Gen Intel® Core™ i5-1145G7 2.60GHz, 8 núcleos. O resultado foi:

    benchStrlenSemBarra.....................I9 - Mo0.022μs (±1.26%)
    benchStrlenComBarra.....................I9 - Mo0.015μs (±1.83%)
    benchInArraySemBarra....................I9 - Mo0.625μs (±3.06%)
    benchInArrayComBarra....................I9 - Mo0.621μs (±0.79%)

Subjects: 4, Assertions: 0, Failures: 0, Errors: 0
+-------------------+----------------------+-----+---------+-----+-----------+---------+--------+
| benchmark         | subject              | set | revs    | its | mem_peak  | mode    | rstdev |
+-------------------+----------------------+-----+---------+-----+-----------+---------+--------+
| TimeConsumerBench | benchStrlenSemBarra  |     | 1000000 | 10  | 707.240kb | 0.022μs | ±1.26% |
| TimeConsumerBench | benchStrlenComBarra  |     | 1000000 | 10  | 707.240kb | 0.015μs | ±1.83% |
| TimeConsumerBench | benchInArraySemBarra |     | 1000000 | 10  | 707.240kb | 0.625μs | ±3.06% |
| TimeConsumerBench | benchInArrayComBarra |     | 1000000 | 10  | 707.240kb | 0.621μs | ±0.79% |
+-------------------+----------------------+-----+---------+-----+-----------+---------+--------+

No caso de strlen, sem a barra o tempo médio foi de 0.022μs (0,022 microssegundos, ou 22 nanossegundos, ou 0,000000022 segundos). Ou seja, 22 bilionésimos de segundo. Adicionando a barra, caiu para 15 nanossegundos. Sim, foi mais rápido, mas lembre-se que foram 10 iterações com 1 milhão de execuções cada (ou seja, cada uma foi executada 10 milhões de vezes).

No caso de in_array, o ganho foi menor ainda, apenas 4 nanossegundos mais rápido com a barra.

Então a menos que seu código seja executado milhões de vezes em um curto intervalo de tempo, ou o desempenho da aplicação seja extremamente crítico (a ponto de alguns nanossegundos fazerem a diferença), eu diria que o ganho em geral será não só imperceptível, como também insignificante.

Para mim, parece mais o típico caso de micro-otimização desnecessária. Em vez de sair colocando a barra em tudo, o ideal - como sempre - é fazer testes de stress adequados em condições reais (ou o mais próximo possível disso) e ver onde de fato estão os gargalos.