bill é diferente de bill_amount, tax é diferente de tax_percent e tip é diferente de tip_percent.

Os nomes dos parâmetros de uma função só existem dentro da função. Fora dela, o que importa é que ela receba uma expressão que resulte em um valor que ela espera receber.

Só para dar um exemplo, eu poderia chamar a função assim:

half(100, 6.25, 18);

Ou seja, em vez de ter variáveis, eu posso muito bem chamar a função passando os valores numéricos diretamente. Claro que para o exercício não serve, mas tecnicamente falando, nada impede que eu faça isso. E ao chamar desta forma, o valor 100 será atribuído ao parâmetro bill_amount, o valor 6.25 será atribuído ao parâmetro tax_percent, e 18, a tip_percent.

Os nomes só existem dentro da função. Fora dela, quem for chamá-la, pode passar qualquer coisa, desde que o resultado seja compatível com os tipos que ela espera.

Tanto que eu também poderia fazer algo assim:

half(valor_batata + valor_cervejas + valor_hamburguer, calcular_taxa_do_dia(), ler_valor_gorjeta());

Assumindo que todas as variáveis valor_batata, valor_cervejas e valor_hamburguer e as funções calcular_taxa_do_dia e ler_valor_gorjeta existam e seus tipos sejam compatíveis com o que a função half espera.

Resumindo, uma coisa são os nomes dos parâmetros, que só existem dentro da função. Outra coisa são os valores dos argumentos que passamos para a função ao chamá-la. Estes podem ser quaisquer expressões (nem precisam ser variáveis), desde que os tipos sejam compatíveis com os respectivos parâmetros. Ou seja, as variáveis que vc leu no main não precisam necessariamente ter os mesmos nomes dos parâmetros definidos na função.

Por fim, a função poderia ser simplificada, pois não vejo a necessidade de tantas variáveis intermediárias:

float half(float bill, float tax, int tip) {
    float tax_multiplier = 1 + (tax / 100);
    float tip_multiplier = 1.0 + (tip / 100.0);
    return (bill * tax_multiplier * tip_multiplier) / 2;
}

No caso do tax_multiplier, como tax é um float, toda a expressão resultará em um float. Já tip é um int, então eu preciso dividir por 100.0 (o .0 no final força que toda a expressão seja float, evitando o arredondamento que ocorreria se eu dividisse por 100, já que este é um literal inteiro).

Ou ainda, caso seja permitido criar funções auxiliares:

// converte um valor de porcentagem para o respectivo multiplicador (ex: 6.5 vira 1.065)
float convert_perc(float perc) {
    return 1.0 + (perc / 100.0);
}

float half(float bill, float tax, int tip) {
    return (bill * convert_perc(tax) * convert_perc(tip)) / 2;
}