Is there a noticeable difference between defining & declaring the struct in one block vs. declaring then defining the struct?

Is there a noticeable difference between defining & declaring the struct in one block vs. declaring then defining the struct?

No.

I want to know if these two are equivalent

Yes.

if so, if one is more efficient:

There is no difference in program execution. These all are abstract C language things, with no effect on program performance.

The first one is more efficient to type, two words less.

both of them are equivalent due to the keyword typedef as in first example :

typedef struct test test;

struct test {
    bigThing* thing;
    anotherThing* thingTwo;
    int var1;
    int var2;
};

when you said typedef struct test test; this means aliasing the type test to struct test which means that wherever you write test , it's same as writing struct test.

but look in the second example you provided:

typedef struct test {
    bigThing* thing;
    anotherThing* thingTwo;
    int var1;
    int var2;
} test ;

due to the keyword typedef , meaning that wherever you write the type test , it's aliased to be

struct test {
    bigThing* thing;
    anotherThing* thingTwo;
    int var1;
    int var2;
}

which is the same but it's not convenient to write it like this , if you don't understand the above example , examine the following code :

    #include <stdio.h>

int main()
{
    struct test{
     int x;
     int y;
    }t1 ;

    t1.x = 10;
    t1.y = 2;

    printf("t1 = {%d, %d}", t1.x, t1.y);

    return 0;
}

and here is image of output :

so in the first code example you write , writing test x; is equivalent to :

struct test x;

while in the second code you provided , writing test x; is equivalent to :

struct test{
 int x;
 int y;
}x;

where both of them are equivalent but for me , it's more convenient to use the declaration of struct as in the first example you provided.

Both your examples will compile to have the same effect. However, the duplication may lead to coders mixing, for instance:

test foobar1;
struct test foobar2;

There is an advantage to using your second example (slightly modified below.)

typedef struct {
    bigThing* thing;
    anotherThing* thingTwo;
    int var1;
    int var2;
} test_t;

This version omits the unnecessary token ahead of the curly brace. It also requires one fewer lines of code to be read and understood. Finally, this version uses a convention of "_t" to indicate that it is a (user defined) datatype.

The exception to one claim above is, for instance, declaring a struct to support a linked list. This will need a pointer to instances of itself. Under these requirements, a token must appear before the curly brace:

typedef struct node {
    int value;
    struct node *next; // "node_t" not encountered yet, so "struct node" required
} node_t;