Jelly, 49 bytes

Øb“¢StỤȤɼẎ'ƙẒ¤IṅO⁴ỊḃġzwḲṃ?ẹȯ¡ɱ9ż]/ṾẎṖ ḞẆṘ’œ?i+⁽$ŀ

A monadic Link that accepts a character and yields a Unicode codepoint.

Try it online! (applies the Link to each character and casts the output to characters.)
Or see the test-suite. (Casts the output of each input character to a character; the actual return value is shown in parentheses.)

How?

Øb“...’œ?i+⁽$ŀ - Link: character, C
Øb             - base-64 characters -> "AB...Zab...z+/"
  “...’        - large base 250 compressed number
       œ?      - permutation of {"AB...Zab...z+/"} at {that} lexicographic index
         i     - index of {C} in {that}
           ⁽$ŀ - 10239
          +    - {foundAt} add {10239}

A fairly augmented (for golf purposes) port of Dominic van Essen's Nibbles answer is also 49 bytes (I thought it may come in at less):

“¦Oŀ"ėO½ı7Y*ỌƲ¤n~3×bḶ£ȯZLȦ~{@o’ḃ;R}ɗ64Q+⁽$ŀɓØbiCị

Try it online!

This uses base \$64\$ rather than base \$62\$ for the compression (as the number has the same number of digits but allows reusing the 64 we need there, rather than having a 62 in the code too).

The C at the end gives us the complement of the index of the input character in the base digits Øb to cater for uppercase letters coming first in that list and the compressed list represented by Øb“...’œ? is for the non-uppercase characters of Øb in reverse. This avoids rotating it by \$26\$ after adding the excess values or subtracting \$26\$ from the index of the input character in Øb.

Python 3.8 (pre-release), 83 bytes

(' '*10240+'+a1bAk2lBcif/mspCe3h9o6rDdjgEntqFG5HIu8vJKLMNxOPQR4S0z7TUVwWXyYZ').find

An unnamed function that accepts a base-64 character and returns a Unicode codepoint.

Try it online!

How?

The function find of a string will return the index of the first occurrence of the provided character (or string) or -1 if not found.

(               ).find # create a `find` function for the result of:
 ' '                   #   a space character
    *10240             #   repeated 10240 times
          +'...'       #   plus the characters in the order we want them

Python 3.8 (pre-release),  139  127 bytes

-12 bytes from Mukundan314 by removing ''.join and chr.

lambda x:x.translate([i+10208for i in b'NOPQSWXY[\\^~~~~~~!#)91+;3*:%\'-=5/?7.>EGZM]U_~~~,T"&2RB6VF4~~~~~~~ $(08<@ACDHIJKL'*2])

Try it online!

Nibbles, 79 nibbles (39.5 bytes)

=+$~+10240`$:`D62,64  41818e7b54ef14f029e55debfc3b7ccc75d232347061bcb4daee62f

Attempt This Online!
(Or try a modified version that maps the output to the corresponding braille characters)

Input as 1-based base64 index; output as UTF8 codepoint.

A port of my R answer.

=+$~+10240`$:`D62,64 418...62f  # full program
             `D62    418...62f  # Number intepreted as base-62 digits
                                # [12,52,2,6,18,...]
            :    ,64            # append 0..63
          `$                    # and discard duplicates;
    +10240                      # now add 10240 to each value
=+$~                            # and modular index by the input+1
                                # (so 64 wraps-around to 1 => 10252)

Nibbles, 92 nibbles (46 bytes)

=?:"/":`,10|_\$a$+10240`$:`D62,64  41818e7b54ef14f029e55debfc3b7ccc75d232347061bcb4daee62f

Attempt This Online!

As above, but with input as character from 0-9a-zA-Z+/.

Constructing and indexing into /0-9a-zA-Z costs +6.5 bytes (?:"/":`,10|_\$a$ instead of just +$~).

05AB1E, 58 bytes

63Ý•4¾À¿¤šM™a
ôнXsñ¼úòðʨ61.öa*yÅS„āÕZq˜ý•.IŽee+çžK„+/«Ikè

Try it online or verify all test cases.

Explanation:

63Ý    # Push a list in the range [0,63]
   •4¾À¿¤šM™a
   ôнXsñ¼úòðʨ61.öa*yÅS„āÕZq˜ý•
       # Push compressed integer 2049286346368099446261761963330067450543276370922574063424309472951718240386544890928807
    .I # Get the 204...807th permutation of list [0,63]:
       #  [1,3,9,25,17,11,27,19,10,26,5,7,13,29,21,15,31,23,14,30,37,39,58,45,61,53,0,4,8,16,24,28,32,33,35,36,40,41,42,43,44,46,47,48,49,51,55,56,57,59,60,62,52,2,6,18,50,34,22,54,38,20,63,12]
Žee+   # Add compressed 10240 to each
    ç  # Convert them from codepoint-integers to braille-characters
žK     # Push constant "abc...xyzABC...XYZ012...789"
  „+/« # Append "+/"
Ik     # Get the index of the input-character in this string
  è    # Use that to index into the braille-characters
       # (after which the braille-character is output implicitly as result)

See this 05AB1E tip of mine (section How to compress large integers?) to understand why •4¾À¿¤šM™a\nôнXsñ¼úòðʨ61.öa*yÅS„āÕZq˜ý• is 2049286346368099446261761963330067450543276370922574063424309472951718240386544890928807 and Žee is 10240.

The 2049286346368099446261761963330067450543276370922574063424309472951718240386544890928807 is generated by this Jelly builtin (minus 1, since Jelly uses 1-based indexing and 05AB1E uses 0-based indexing).

Charcoal, 64 bytes

℅⁺¹⁰²⁴⁰⍘Ｓ”xM∨⍘‴|κ⌊DΠ3XN⁻ⅈ·→∕\`Ｗ｜↘ΦχＤＨ▷GΦＣ⊗⊖υh↧Ｚp⟧¡↑➙⊗'⊙.η↔⌊Ｂ″&xZ

Try it online! Link is to verbose version of code. Explanation: Looks up the index of the input character in a compressed version of @Arnauld's transliteration string, then adds 10240 to give the Braille character.

I tried hardcoding only the digits and lowercase letters but that came to 74 bytes:

Ｆφ⊞υ+§≔υ¹²/Ｆ³⁶§≔υ⍘§”\`=?⁴vL8↷λＪ_ü=ζi⊙Ｕ⁼,A]⁴ιÞ↘×Ｈ1+”ιφ⍘ιφＦα§≔υ⌕υ+ι℅⁺¹⁰²⁴⁰⌕υＳ

Try it online! Link is to verbose version of code. Explanation:

Ｆφ⊞υ+

Start with an array of +s.

§≔υ¹²/

Put / in its correct location.

Ｆ³⁶§≔υ⍘§”...”ιφ⍘ιφ

Using a compressed look-up table, put the digits 0-9 and the lowercase letters a-z in their correct locations.

Ｆα§≔υ⌕υ+ι

Put the uppercase letters in the remaining locations.

℅⁺¹⁰²⁴⁰⌕υＳ

Look up the input character and output the corresponding Braille character.

I even tried @DominicvanEssen's idea of utilising the pattern of the runs of 10 letters and digits but even with my experimental array indexing branch it still weighed in at 78 bytes. No link because it doesn't actually work anywhere online yet. Explanation:

≔Ｅ139phbrjaq⍘ιφη

Get the pattern of 10.

Ｆφ⊞υ+§≔υ¹²/

Get the array of +s with the / inserted as before.

§≔υ⟦⁺⁺⁺η⁺⁴ηＥBDWJZR⍘ιφ⊗η⟧⁺β⭆χ﹪⊕ιχ

Use the pattern of 10 to calculate the positions of the letters a-j, k-t, insert the positions of the letters u-z, then use the pattern to get the positions of 1-0, and then assign all of those letters and digits correspondingly.

Ｆα§≔υ⌕υ+ι℅⁺¹⁰²⁴⁰⌕υＳ

Fill the uppercase letters and output the appropriate Braille character for the input character as before.

R, 95 86 93 bytes

Edit: +7 bytes to fix incorrect mapping of /, spotted by Neil

function(x)unique(c(utf8ToInt("/W%)5UE9YI7$&,<4.>6-=(*0@82B:1AHJ]P`X"),36:99))[x%%64+1]+10205

Attempt This Online!

Input as 1-based base64 index; output as UTF8 codepoint.

Hard-codes 0-9a-z/ and assigns the remaining codpoints to A-Z+ in order.

R, 129 bytes

function(x,d=c(2,6,16,-8,-6,16,-8,-9))(unique(c(cumsum(c(0,40,-50,2*d,-19,d,16,-21,d,16,7,2,19,-13,16,-8)),1:64))+10252)[x%%64+1]

Attempt This Online!

Input as 1-based base64 index; output as UTF8 codepoint.

Tries to take advantage of the pattern [2,6,16,-8,-6,16,-8,-9] that is repeated 3 times (first repeat is doubled) in the differences between consecutive 0-9a-z codepoints.
I doubt that this will actually end-up the shortest approach, though. It didn't.

Retina 0.8.2, 79 bytes

T`Aa1bBk2\lCcif/ms\pDe3\h9\o6r\E\djgFntqG\H5IJu8vK-OxP-S4T0z7UVW\wXYyZ+`⠀-⠿

Try it online! Link includes test input. Explanation: Uses @Arnauld's transliteration string, but certain letters magic to Retina need to be escaped with \, while there are a couple of character ranges that can be abbreviated using - saving a few bytes. (Retina does allow UTF-8 encoding as here although TIO assumes you'll only use ISO-8859-1.)

JavaScript (Node.js), 105 bytes

c=>Buffer([226,160,"Aa1bBk2lCcif/mspDe3h9o6rEdjgFntqGH5IJu8vKLMNOxPQRS4T0z7UVWwXYyZ+".indexOf(c)+128])+""

Try it online!