To start with, in Erlang we will deal a lot with list data type. One starting point is to familiarize with the concise lists function from Erlang documentation.
Back to the question, folders are like tree, so need to walk down the path from root to all branches.

count_folder(Folders, AccumulatorIn) ->
    {_CurrentFolder, ListSubfolders} = Folders,
    case ListSubfolders of
        [] ->   %%Base case, i.e. folder has no sub-folders -> return 1 (count of CurrentFolder is always 1) + Accumulator from previous calculation
                1 + AccumulatorIn;
         _ ->   %%Recursive case, i.e. folder has sub-folders -> count for each ListSubfolders recursively
                CountListSubfolder = lists:foldl(fun count_folder/2, 0, ListSubfolders),
                1 + AccumulatorIn + CountListSubfolder
    end.

Howto call from main function:

...
Cnt = count_folder(Folders, 0),
io:format("Count: ~p~n", [Cnt]), 
...

I add this answer to complete @Agus one's.
As you are starting with Erlang, it is a good idea to get familiar with recursion. It is central in Erlang, despite of the fact that Erlang's libraries take care of it in numerous situations : lists, maps, gb_trees, gen_server, gen_statem ... and therefore it seems to disappear in many cases.
At the very beginning, I advice you to avoid the usage of those libraries until you master the concept of recursion and tail recursion. Then, as Agus says, you should dig into the numerous Erlang libraries, they already solve most of the common problems you could have.
In your code, you are using list comprehension. It is an elegant syntax (in my opinion) but I think that it does not fit to your goal (mastering recursion) and, in the particular cases you used it, it hides what you are really doing:

[H || H <- DD, filelib:is_dir(Path ++ "/" ++ H) =:= true],

Here you want to filter the directories, I think that lists:filter/2 is more explicit (even if the comprehension syntax is easy to understand in this case):

lists:filter(fun(X) -> filelib:is_dir(filename:join(Path,X)) end, DD),

At the end of my answer, I propose you a code were I have used a "hand made" recursion

filterDirs(DD,Path,[]),

With

{Path, [folders(Path ++ "/" ++ H2) || H2 <- A]},

You want to map the function folders/1 on each element of A, lists:map/2 does exactly this

{Path, lists:map(fun(X) -> folders(filename:join(Path,X)) end , A)},

Finally, with

[pretty_print(Subfolder, Depth+1,Count + 1)|| Subfolder <- ListSubfolders],

The list comprehension does not what you expect, like in previous case it simply maps the function pretty_print on each element of the list A, while you want to accumulate on each element. The function lists:foldl/3 does this (it needs a modification of the pretty_print function)

lists:foldl(fun(X,Acc) -> pretty_print(X, Depth+1, Acc + 1) end, Count, ListSubfolders);

In my example I propose a different hand made version that also print the result in a more standard tree representation.

pretty_print(ListSubfolders,Depth+1,{Count+1, Sign ++ AddSign}).

-module(tut).
-export([main/1]).

main(Path) -> 
    Folders = folders(Path),
    pretty_print(Folders, 0, {1," "},true) - 1.

folders(Path) ->
    {ok, DD} = file:list_dir(Path),
    Dirs = filterDirs(DD,Path,[]),
    {Path,folders(Dirs,Path,[])}.

% I split the pretty print function in 2 parts. The first one takes care of the tuple and prints
% the current folder. It calls the second part to handle the sub-folder list,
% incrementing both the depth and count and evaluates the new "Sign"
% It needs to know if this tuple was the last of the sub-folder list where it belonged
% to adapt the "Sign" value 
pretty_print({CurrrentFolder, ListSubfolders}, Depth, {Count,Sign},Last) ->
    io:format("Depth -> ~3.B| Count -> ~3.B~s+--~s~n",
              [Depth,Count,Sign, filename:basename(CurrrentFolder)]),
    AddSign = case Last of 
        true -> "   ";
        false -> "|  "
    end,    
    pretty_print(ListSubfolders,Depth+1,{Count+1, Sign ++ AddSign}).

% The second part iterates on each sub-folder, it returns the Count value on completion
% and uses it for next element.
pretty_print([H|T],Depth,{Count,Sign}) ->
    NewCounter = pretty_print(H,Depth,{Count,Sign},T == []),
    pretty_print(T,Depth,{NewCounter,Sign});
pretty_print([],_,{Count,_}) ->
    Count.
 
filterDirs([],_,R) -> lists:reverse(R);
filterDirs([H|T],Path,R) ->
    case filelib:is_dir(filename:join(Path,H)) of
        true ->
            filterDirs(T,Path,[H|R]);
        false ->
            filterDirs(T,Path,R)
    end.

folders([],_,R) -> lists:reverse(R);
folders([H|T],Path,R) -> folders(T,Path,[folders(filename:join(Path,H))|R]).

It gives:

1> c(tut).                                                     
{ok,tut}
2> tut:main("C:/temp").
Depth ->   0| Count ->   1 +--temp
Depth ->   1| Count ->   2    +--t1
Depth ->   1| Count ->   3    +--testdisk-7.2-WIP
Depth ->   2| Count ->   4    |  +--63
Depth ->   2| Count ->   5    |  +--platforms
Depth ->   1| Count ->   6    +--u_test
Depth ->   2| Count ->   7       +--a_dir
Depth ->   2| Count ->   8       +--b_dir
8
3>