Why can you initialize a string pointer as a string literal, but not as an array?

There's no fundamental reason for this -- it's just the way the language was originaly defined.

The basic syntax for array initialization is

type array[] = {value, value, value};

The basic syntax for pointer initialization is

type *pointer = value;

But then we have string literals. And it turns out that, deep down inside, the compiler does two almost completely different things with string literals.

If you say

char array[] = "string";

the compiler treats it just about exactly as if you had said

char array[] = { 's', 't', 'r', 'i', 'n', 'g', '\0' };

But if you say

char *p = "string";

the compiler does something quite different. It quietly creates an array for you, containing the string, more or less as if you had written

char __hidden_unnamed_array[] = "string";
char *p = __hidden_unnamed_array;

But the point -- the answer to your question -- is that the compiler does this special thing only for string literals. In the original definition of C, at least, there was no way to use the {value, value, value} syntax to create a hidden, unnamed array that you could do something else with. The {value, value, value} syntax was only defined as working as the direct initializer for an explicitly-declared array.

As @pmg mentions in a comment, however, newer versions of C have a new syntax, the compound literal, which does let you, basically, "use the {value, value, value} syntax to create a hidden, unnamed array to do something else with". So you can in fact write

char *word2 = (char[]){'a', 'b', 'c', '\0'};

and this works just fine. It works in other contexts, too: for example, you can say things like

printf("%s\n", (char[]){'d', 'e', 'f', '\0'});

Going back to a side question you asked: when you wrote

char *word2 = {'a', 'b', 'c', '\0'};

the compiler said to itself, "Wait a minute, word2 is one thing, but the initializer has four things. So I'll throw away three, and warn the programmer that I'm doing so." It then did the equivalent of

char *word2 = {'a'};

and if you later tried something like

printf("%s", word2);

you got a crash when printf tried to access address 0x00000061.

In general, the type of the initializer must match the type of what is being initialized.

This works:

char *word1 = "abc";

Because a string constant has type array of char and such an array decays to type char * when used in an expression or initialization, so this matches the declared type.

This works:

char word2[] = {'a', 'b', 'c', '\0'};

Because an array of char is being initialized with an initializer list of characters (technically they have type int but are converted to char).

This gives a warning:

char *word2 = {'a', 'b', 'c', '\0'};

Because an initializer list is being used to initialize a type which is not an array or struct.

And this is OK:

char word1[] = "abc";

Because the C standard specifically allows initializing a char array with a string literal, as specified in section 6.7.9p14:

An array of character type may be initialized by a character string literal or UTF−8 string literal, optionally enclosed in braces. Successive bytes of the string literal (including the terminating null character if there is room or if the array is of unknown size) initialize the elements of the array.