Why must C++ function parameter packs be placeholders or pack expansions?

Why does the standard impose this restriction?

I'll focus on the "why's", as other answer already visits various workarounds.

P1219R2 (Homogeneous variadic function parameters) went as far as EWG

# EWG incubator: in favor
SF F N A SA
5  2 3 0 0

But was eventually rejected for C++23 by EWG

SF F N A SA
2  8 8 9 2

I think the rationale was that whilst the proposal was very well-written the actual language facility was not an essentially useful one, and particularly not enough to hold its weight given that it's a breaking change due to the C varargs comma mess:

The varargs ellipsis was originally introduced in C++ along with function prototypes. At that time, the feature did not permit a comma prior to the ellipsis. When C later adopted these features, the syntax was altered to require the intervening comma, emphasizing the distinction between the last formal parameter and the varargs parameters. To retain compatibility with C, the C++ syntax was modified to permit the user to add the intervening comma. Users therefore can choose to provide the comma or leave it out.

When paired with function parameter packs, this creates a syntactic ambiguity that is currently resolved via a disambiguation rule: When an ellipsis that appears in a function parameter list might be part of an abstract (nameless) declarator, it is treated as a pack declaration if the parameter's type names an unexpanded parameter pack or contains auto; otherwise, it is a varargs ellipsis. At present, this rule effectively disambiguates in favor of a parameter pack whenever doing so produces a well-formed result.

Example (status quo):

template <class... T>
void f(T...); // declares a variadic function template with a function parameter pack

template <class T>
void f(T...); // same as void f(T, ...)

With homogeneous function parameter packs, this disambiguation rule needs to be revisited. It would be very natural to interpret the second declaration above as a function template with a homogeneous function parameter pack, and that is the resolution proposed here. By requiring a comma between a parameter list and a varargs ellipsis, the disambiguation rule can be dropped entirely, simplifying the language without losing any functionality or degrading compatibility with C.

This is a breaking change, but likely not a very impactful one. [...]

Why does the standard impose this restriction?

Most likely because this would confuse(or create complications) users with the old C varargs function that have almost same syntax(with unnamed parameter) as shown below:

//this is a C varargs function
void good3(int...) 
           ^^^^^^
{
    
}

Now if the fourth function bad was allowed:

 
template<int = 0> void bad(int...i)
                           ^^^^^^^ --->this is very likely to confuse users as some may consider it as a C varargs function instead of a function parameter pack 
{
}

IMO the above seems atleast a little ambiguous due to the similarity in the syntax of C varargs and a function parameter pack.

From dcl.fct#22:

There is a syntactic ambiguity when an ellipsis occurs at the end of a parameter-declaration-clause without a preceding comma. In this case, the ellipsis is parsed as part of the abstract-declarator if the type of the parameter either names a template parameter pack that has not been expanded or contains auto; otherwise, it is parsed as part of the parameter-declaration-clause.

I'd like a function that works when you say good(1, 2U, '\003')

You can use std::common_type for this.

template <typename... T, typename l= std::common_type_t<T...>>
void func(T&&... args) {
}

Am I missing some trick that would allow one to write a function that takes a variable number of arguments of a specific type?

The good3 given in your example is very readable and should be used from C++20. Though if one is using C++17 then one way to do this is using the SFINAE principle with a combination of std::conjunction and std::is_same as shown below.

Method 1

Here we simply check if all the arguments passed are of the same type.

template <typename T, typename ... Args>
std::enable_if_t<std::conjunction_v<std::is_same<T, Args>...>, bool>
func(const T & first, const Args & ... args)
{
    std::cout<<"func called"<<std::endl;
    return true;
}
int main()
{
    func(4,5,8);    //works
    //func(4,7.7); //wont work as types are different
    std::string s1 = "a", s2 = "b"; 
    func(s1, s2);  //works
    //func(s1, 2);   //won't work as types are different
    
}

Working demo

Looking at your comment it seems you want to add one more restriction that the program should work only when

a) all the arguments are of the same type

b) all of those matches a specific type say int, or std::string.

This can be done by adding a static_assert inside the function template:

static_assert(std::is_same_v<T, int>, "Even though all parameters are of the same type, they are not int");

Method 2

Here use the static_assert shown above to check if the arguments passes are of a specific type like int.

template <typename T, typename ... Args>
std::enable_if_t<std::conjunction_v<std::is_same<T, Args>...>, bool>
func(const T & first, const Args & ... args)
{
    static_assert(std::is_same_v<T, int>, "Even though all parameters are of the same type, they are not int");
    std::cout<<"func called"<<std::endl;
    return true;
}

int main()
{
    func(3,3);    //works
    //func(4,7.7); //wont work as types are different
    std::string s1 = "a", s2 = "b"; 
    //func(s1, s2);  //won't work as even though they are of the same type but not int type
    
}

Working demo

Am I missing some trick that would allow one to write a function that takes a variable number of arguments of a specific type?

If I understand the question correctly, you can work around it by adding a proxy function that casts and forwards arguments to actual implementation:

unsigned wrap_sum(auto&&...args) {
  return []<std::size_t...I>(std::index_sequence<I...>,
                             std::conditional_t<true, unsigned, decltype(I)> ... args) {

    return (0u + ... + args);

  }(std::make_index_sequence<sizeof...(args)>{},
    std::forward<decltype(args)>(args)...);
}