JavaScript (ES6), score 10

These are individual expressions. Couldn't figure out an 11, even with a literal 1 in my back pocket...

~~!!`OH my Z#$@...`
!``+!``
3 // wildcard 
4
~4*~``
6 // wildcard
7 // wildcard
8 // wildcard
9
0xA // wildcard 0

It's kind of wild that even with all the letters available, there isn't a single object that I could find in the browser environment with a matching name:

Object.getOwnPropertyNames(window).filter(m=>m.match(/^[AHILOQZTefmpxy]*$/))

Not sure what I would have done with that exactly but, still.

Vyxal, 18 snippets, 9 wildcards, 86 bytes

=
y!
eT
4
5
6
7
8
9
₀
eSm
$..!T
`||||{xQQQ))) `L
14
\fH
$.!!:*
`~~~~~~~~~||@@@()%`L
18

Try it Online!

The wildcard bytes are 5678₀SL18. Several of these are just pushing the number, but the rest are:

=                    # (0 == 0) = 1
y!                   # uninterleave 0 to push two values, take stack length = 2
eT                   # (0 ** 0) * 3 = 3
eSm                  # (0 ** 0) = 1, stringify = "1", double = "11"
$..!T                # Push four values to the stack, take the stack length and triple it to get 12
`||||{xQQQ))) `L     # Length of string with length 13
\fH                  # Convert "f" from hexadecimal for 15
$.!!:*               # Push four values to the stack, take the stack length and square it to get 16
`~~~~~~~~~||@@@()%`L # Length of string with length 17

SmileBASIC, 12 snippets, 5 wildcards, 31 bytes

!.     '. is parsed as the number 0.0; taking the logical not gives 1
!.+!.  'Previous value added to itself
@Q||Q  '@Q is a label string and Q is a variable. For some reason, certain comparison/logical operations between strings and numbers return 3 rather than 1 or 0. 
4      '4
#TLIme 'Constant for the text color lime green, value is 5.
6      '6 (wildcard)
7      '7 (wildcard)
8      '8 (wildcard)
9      '9
&HA    'Hexadecimal A
11     '11 (one of them is a wildcard)
4*3    '4 multiplied by 3 (3 is wildcard)

I could've also used a variable instead of . (variables start at 0), and a string variable (like Q$) instead of @Q

Characters used: !!!#&*+...1449@AHILQQTem||

Wildcards used: 67813

unused characters: !!$$%()))):=@@OQTZ\\^`````````efpxy{||~~~~~~~~~

CJam, 25 snippets, 12 wildcards, 64 bytes

1
Q!)
Z
4
5
6
L``(*$)#
8
9
T!T
B
C
D
E
F
G
H
I
J
K
O`e`~~!!
B`:)
Q``$e`~~@~@=~+
Q!)4
Amf

Try it online!

Wildcards:

568BBCDEFGJK

I feel that I have to post quickly, before Dennis outgolfing me.

JavaScript, 8 numbers, 4 wildcards

 1: 1
 2: -~!``
 3: 4+~!$
 4: ~!``*~!``
 5: 4|!$
 6: 0xf^9
 7: 7
 8: 8

I might try again later - I'm kind of wasting characters on 2 and 6, when you get down to it.

JavaScript, 10 numbers, 5 wildcards

Remaining characters: !!#$$%&())))*...:=@@@HILOQQQTTZ\^```eefmpy{|||~~~~~~~~~

5/5 bonus characters used: 37680

Programs:

1. 1

2. !``+!``

3. 3
4. 4
5. 4|!``
6. 6
7. 7
8. 8
9. 9
10. 0xA

I had hoped one of the strings I could make using \xAB would be a number, but unfortunately none of the combinations I tried would yield any. The ^ (XOR) character would also be interesting to use, but I currently don't see any opportunities where it can be used to make a great enough number.

If you see another feasible combination, let me know in the comments.

Edit: Added #10 thanks to Arnauld

Pushy, 10 numbers (4 wildcards)

All of these are snippets which leave the result on the stack. You can test this in the online interpreter by appending # to each snippet (to print the number)

A(      \ 1:  Get alphabet and check that 'Z' >= 'Y'. Results in 1 (True)
x&+     \ 2:  Check stack equality (True - both are empty) then duplicate and sum.
3       \ 3:  Push 3 (1 wildcard)
4       \ 4:  Push 4
1 4+    \ 5:  1 + 4 in postfix, leaves 5 on the stack (1 wildcard)
`L`T%   \ 6:  Get character code of 'L' and modulo by T (ten) - leaves 6 on the stack
7       \ 7:  Push 7 (1 wildcard)
8       \ 8:  Push 8 (1 wildcard)
9       \ 9:  Push 9
T       \ 10: Push 10

This answer is not yet complete - although it seems unlikely I will get much further.

Befunge-98, 4 snippets, 18 bytes, 2 wildcards

!.@
!:+.@
41-.@    wildcard 1 = -
4.#A9H   wildcard 2 = .

Characters left: !!!$$%&())))*=ILOQQQTTZ\^`````````eefmpxy{||||~~~~~~~~~

I doubt more are possible, since every extra program will require a form of output, and all ., are already used up. If I can figure out a way to make 3 and 5 without a wildcard, then it's possible.

The last program will eventually terminate due to the stack filling up. A and H with no fingerprints loaded will reflect, and the program will keep pushing 9's.

Hexagony, 6 numbers, 3 wildcards, 23 bytes

1!@
))!@
)|\@$!
4!%
4)!:
6!@

Try it online!

The entire sixth program is made from wildcards.

The only really interesting one is 3. While I could do that as 4(!@, that would leave me without a 4 to generate 5 easily, so I went with this instead:

 ) |
\ @ $
 ! .

Due to the |, the ) on the first line is run twice, before the IP wraps to right-hand corner. $ skips over the @, and then the \ redirects the IP through the ) a third time. The IP wraps to the bottom left corner, ! prints the 3 and @ terminates the program.

I don't think more than 6 snippets are possible, because there are only 5 printing commands (!!!!!) and 5 commands that can be used to terminate the program (@@@%:). So after the fifth snippet, we need at least two wildcards per snippet. Hence, even if I managed to get 6 without using a wildcard for it, there wouldn't be enough wildcards left to go to snippet seven.

05AB1E, 12 numbers, 6 wildcards

 1:    1                                   -> 1
 2:    )O!x                                -> sum([])!*2
 3:    4L`\                                -> 2nd_last(range(1...4))
 4:    4                                   -> 4
 5:    5        # wildcard 1 = 5           -> 5
 6:    6        # wildcard 2 = 6           -> 6
 7:    Tf`~                                -> or(last2(prime_factors(10)))
 8:    8        # wildcard 3 = 8           -> 8
 9:    9                                   -> 9
10:    T                                   -> 10
11:    A`Q!T+   # wildcard 4 = T           -> (y==z)!+10
12:    TÌ       # wildcard 5,6 = T,Ì       -> 10+2

Octave, 6 numbers, 3 wildcards

1: ~~I          % not(not(sqrt(-1))) evaluates to true (or 1)
2: 2            % Wildcard
3: 3            % Wildcard
4: 4
5: (T=4)+~~T    % Create a variable T=4, then add not(not(T)) which evaluates to 1.
6: 6            % Wildcard

I still have 1, 9 and * left, but I don't know if it will help me much. I'll see what I can do with those :)

Not easy getting many numbers when not using an Esolang. I'm hoping I'll be able to get one or two more, but I think it'll be hard.

CJam, 23 snippets, 11 wildcards, 45 bytes

Q!
Q!)
Z
4
4)
6
7
8
9
A
B
C
D
E
F
G
H
I
J
QT|T+e`
O!)1
L!`e`(:)
6mf

Try it online! | wildcard counter (ignore the newlines)

Pyth, 12 snippets, 20 bytes (6 wildcards)

f@

Find the first number where root(n,n) is truthy, starting from 1. Output: 1

y!H

Double not {}. Output: 2

3

Wildcard #1. Output: 3

4

Output: 4.

5

Wildcard #2. Output: 5

6

Wildcard #3. Output: 6

7

Wildcard #4. Output: 7

8

Wildcard #5. Output: 8

9

Output: 9

T

Preinitialized variable. Output: 10

+T!Z

Ten plus not zero. Output: 11

12

Wildcard #6 (2). Output: 12