Absolutely valid. Usually, you can take full advantage of this way by defining two types together:

typedef struct
{
 int a;
 int b;
} S1, *S1PTR;

Where S1 is a struct and S1PTR is the pointer to this struct.

You cannot use pEDGE within the definition of the struct. You shoud do something like:

typedef struct edge {
    pEDGE_ITEM          *edge_item;  
    struct edge         *next;      //pointer to next edge
    struct edge         *prev;      //pointer to prev edge
} EDGE, *pEDGE;

You must also note that edge_item is a double pointer. You also mention that in your question. So if you use pEDGE_ITEM and you just want to have a normal pointer you should not write pEDGE_ITEM *edge_item but just pEDGE_ITEM edge_item.

For clarifying, all the following declarations are equivalent:

struct edgeitem *edge_item;
EDGE_ITEM *edge_item;
pEDGE_ITEM edge_item;

But

pEDGE_ITEM *edge_item;

is equivalent to

struct edgeitem **edge_item;
EDGE_ITEM **edge_item;

About *EDGE next that is wrong syntax. The correct syntax would be EDGE* next or pEDGE next. So once struct edge is defined you can just use any of these two, but while defining the struct, you must do as I show at the beginning of my answer.

Yes, the following two definitions are equivalent:

typedef struct edge_list {
    EDGE        *head;
} EDGE_LIST;

typedef struct edge_list {
    pEDGE        head;
} EDGE_LIST;

PMYSTRUCT ms = NULL;

is equal to

MYSTRUCT* ms = NULL;

You can typedef them at the same time:

typedef struct Node {
    int data;
    struct Node *nextptr;
} node, *node_ptr;

This is arguably hard to understand, but it has a lot to do with why C's declaration syntax works the way it does (i.e. why int* foo, bar; declares bar to be an int rather than an int*

Or you can build on your existing typedef:

typedef struct Node {
    int data;
    struct Node *nextptr;
} node;

typedef node* node_ptr;

Or you can do it from scratch, the same way that you'd typedef anything else:

typedef struct Node* node_ptr;

The definition

typedef struct node *ptr;

will make ptr an alias for struct node *.

Afterwards you can do either

struct node *some_pointer;

Or

ptr some_pointer;

Both will define the variable some_pointer to be a pointer to the node structure.

But making type-aliases of pointer types is not something I recommend. It can make the code harder to read, understand and maintain.

Take for example the most common problem that I've seen here on Stack Overflow when it comes to pointer type aliases:

ptr some_pointer = malloc(sizeof(ptr));

That allocates memory enough for a pointer to the structure, not for the whole structure. If using e.g.

Node *some_pointer = malloc(sizeof(Node*));

that error would be much clearer and easier to find.

See Is it a good idea to typedef pointers?