How to make a dynamic string?

It is simpler to use getchar() to read individual bytes from the file. Also check for allocation and reallocation failures:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int len = 0;
    char *cad, *new_cad;
    int c;

    printf("word: ");

    cad = malloc(len + 1);
    if (cad == NULL) {
        printf("memory allocation failure\n");
        return 1;
    }
    while ((c = getchar()) != EOF && c != '.') {
        cad[len] = (char)c;
        len++;
        new_cad = realloc(cad, len + 1);
        if (new_cad == NULL) {
            printf("memory allocation failure\n");
            free(cad);
            return 1;
        }
        cad = new_cad;
    }
    cad[len] = '\0';

    printf("tam: %d, string: %s\n", len, cad);
    free(cad);

    return 0;
}

Reallocating the dynamic string one byte at a time is inefficient but implementing a better strategy is an optimisation. First focus on correctness, only optimize if needed as proven by careful benchmarking.

How to make a dynamic string?

Read carefully a book such as Modern C, then refer to a good C reference website. Read the documentation of your C compiler (perhaps GCC) and debugger (perhaps GDB). Of course, read with attention the documentation of every function (e.g. scanf) that you are using.

 while(c != '.'){
   scanf("%c", c);
   cad[i] = c;
   i++;
   cad = realloc(cad, (i + 1)*sizeof(char));
 }

Your code above is both wrong and inefficient.

It is wrong, since you use scanf (wrongly: should be scanf("%c", &c) but you really want to use getchar) and realloc but don't handle their failure case

It is inefficient, because you probably don't want to reallocate the string at every loop. Unless you are very tight on memory (in practice, improbably) you should consider using realloc only once in a while (since realloc is probably a costly operation). You could for example first malloc a buffer of 128 bytes, and realloc it only when needed (when you did read 127 bytes) to e.g. newsize=3*oldsize/2 (so the second time to 192 bytes, etc...)

And if you compiled with all warnings and debug info (e.g. gcc -Wall -Wextra -g) you'll get useful warnings.

Made all the changes, this should give you the desired output.

#include <stdio.h>
#include <stdlib.h>
int main(){
   int i = 0, tam = 0;
   char *cad = (char*)malloc(sizeof(char));
   char c = 'l';

   printf("word: ");

   while(c != '.'){
       c= getchar();
       cad[i] = c;
       i++;
       cad = realloc(cad, (i + 1)*sizeof(char));
   }
   cad[i] = '\0';

/*
As pointed out by Bruno, this for loop just calculates the length of the char array, so commented this
for(i = 0; cad[i] == '\0'; i++){
    tam++;
}
printf("tam: %d\n", tam);
*/
printf("tam: %d\n", i);

   return 0;
}

Two bits of advice:

1. realloc is a relatively expensive operation, and you really don't want to do it for each character. A common technique is to double the buffer size as necessary - this will minimize the total number of realloc calls. You may wind up with some internal fragmentation, but on average it shouldn't be too bad.

2. If realloc cannot extend the buffer, it will return NULL and leave the original buffer in place. Thus, you do not want to assign the result of realloc back to the original pointer without checking it first, otherwise you could lose your reference to the previously allocated memory.

It would also be better to use getchar or fgetc for reading the input as opposed to scanf.

So:

#define START_SIZE 2
...
size_t size = START_SIZE;  // tracks the size of the buffer
size_t length = 0;         // tracks the length of the string in the buffer
char *cad = calloc( size, sizeof *cad ); 

/**
 * **ALWAYS** check the result of a malloc, calloc, or realloc call.
 */
if ( !cad )
{
  fprintf( stderr, "Couldn't allocate initial buffer, bailing out here...\n" );
  return EXIT_FAILURE;
}

for ( int c = getchar(); c != '.' && c != EOF; c = getchar() )
{
  /**
   * First, make sure we still have room in our buffer (accounting for the
   * zero terminator) - if we don't, double it.
   */
  if ( length + 1 == size )
  {
    char *tmp = realloc( cad, sizeof *cad * ( 2 * size ) );
    if ( !tmp )
    {
      fprintf( stderr, "realloc failed, exiting loop with what we've read so far\n" );
      break;
    }      
    cad = tmp;
    size *= 2;
  }
  cad[length++] = c;
  cad[length] = 0;   // terminate the string as we go
}