Vtyjkyuk

If I make a command that takes one argument, and the argument should be allowed to take the unescaped default macro char: # as an argument and then treat it as a letter:

documentclassarticle
makeatletter
defallowhash#1
 toks@#1catcode`#11relaxscantokensexpandafterthetoks@%

makeatother
begindocument
allowhashOne hash: #, not two
enddocument

The above works except it prints the following:
One hash: ##, not two. Is this expected behaviour? How could one fix this?

Let's look at your code:

documentclassarticle
makeatletter
defallowhash#1
 toks@#1catcode`#11relaxscantokensexpandafterthetoks@%

makeatother
begindocument
allowhashOne hash: #, not two
enddocument

LaTeX does fetch an argument for allowhash, hereby tokenizing the tokens which form that argument under normal category-code-régime. Thus LaTeX does fetch an explicit-hash-character-token of category code 6(parameter) as a component of allowhash's argument.

When expanding allowhash, this token becomes a part of the content of toks@.

Thus toks@ contains an explicit-hash-character-token of category code 6(parameter).

Due to expandafter...the-trickery this explicit-hash-character-token of category code 6(parameter) ends up as a component of the ⟨general text⟩ of scantokens.

scantokens emulates unexpanded-writing the tokens from its ⟨general text⟩ into file and reading them back from the file and hereby tokenizing things under the current category-code-régime.

When writing to file or screen, explicit character tokens of category-code 6(parameter) get doubled.

Thus the hash gets doubled by scantokens unexpanded-writing-part.

Off the cuff I can only offer a routine ReplaceEveryHash which takes one argument and does replace each explicit catcode-6-character-token of the argument by its stringification—this mechanism does not act only on explicit catcode-6-hashes but on all explicit catcode-6-character-tokens.

documentclassarticle

makeatletter
%%=============================================================================
%% Paraphernalia:
%% UD@firstoftwo, UD@secondoftwo,
%% UD@PassFirstToSecond, UD@Exchange, UD@removespace
%% UD@CheckWhetherNull, UD@CheckWhetherBrace,
%% UD@CheckWhetherLeadingSpace, UD@ExtractFirstArg
%%=============================================================================
newcommandUD@firstoftwo[2]#1%
newcommandUD@secondoftwo[2]#2%
newcommandUD@PassFirstToSecond[2]#2#1%
newcommandUD@Exchange[2]#2#1%
newcommandUD@removespaceUD@firstoftwodefUD@removespace %
%%-----------------------------------------------------------------------------
%% Check whether argument is empty:
%%.............................................................................
%% UD@CheckWhetherNull<Argument which is to be checked>%
%% <Tokens to be delivered in case that argument
%% which is to be checked is empty>%
%% <Tokens to be delivered in case that argument
%% which is to be checked is not empty>%
%%
%% The gist of this macro comes from Robert R. Schneck's ifempty-macro:
%% <https://groups.google.com/forum/#!original/comp.text.tex/kuOEIQIrElc/lUg37FmhA74J>
newcommandUD@CheckWhetherNull[1]%
 romannumeral0expandafterUD@secondoftwostringexpandafter
 UD@secondoftwoexpandafterexpandafterstring#1expandafter
 UD@secondoftwostringexpandafterUD@firstoftwoexpandafterexpandafter
 UD@secondoftwostringexpandafterexpandafterUD@firstoftwo %
 UD@secondoftwoexpandafterexpandafterUD@firstoftwo UD@firstoftwo%
%
%%-----------------------------------------------------------------------------
%% Check whether argument's first token is a catcode-1-character
%%.............................................................................
%% UD@CheckWhetherBrace<Argument which is to be checked>%
%% <Tokens to be delivered in case that argument
%% which is to be checked has leading
%% catcode-1-token>%
%% <Tokens to be delivered in case that argument
%% which is to be checked has no leading
%% catcode-1-token>%
newcommandUD@CheckWhetherBrace[1]%
 romannumeral0expandafterUD@secondoftwoexpandafterexpandafter%
 string#1.expandafterUD@firstoftwoexpandafterexpandafter
 UD@secondoftwostringexpandafterexpandafterUD@firstoftwo %
 UD@firstoftwoexpandafterexpandafterUD@firstoftwo UD@secondoftwo%
%
%%-----------------------------------------------------------------------------
%% Check whether brace-balanced argument starts with a space-token
%%.............................................................................
%% UD@CheckWhetherLeadingSpace<Argument which is to be checked>%
%% <Tokens to be delivered in case <argument
%% which is to be checked>'s 1st token is a
%% space-token>%
%% <Tokens to be delivered in case <argument
%% which is to be checked>'s 1st token is not
%% a space-token>%
newcommandUD@CheckWhetherLeadingSpace[1]%
 romannumeral0UD@CheckWhetherNull#1%
 expandafterexpandafterUD@firstoftwo UD@secondoftwo%
 expandafterUD@secondoftwostringUD@CheckWhetherLeadingSpaceB.#1 %
%
newcommandUD@CheckWhetherLeadingSpaceB%
longdefUD@CheckWhetherLeadingSpaceB#1 %
 expandafterUD@CheckWhetherNullexpandafterUD@secondoftwo#1%
 UD@ExchangeUD@firstoftwoUD@ExchangeUD@secondoftwo%
 UD@Exchange expandafterexpandafterexpandafterexpandafter
 expandafterexpandafterexpandafterexpandafterexpandafter
 expandafterexpandafterUD@secondoftwoexpandafterstring%
%
%%-----------------------------------------------------------------------------
%% Extract first inner undelimited argument:
%%
%% UD@ExtractFirstArgABCDE yields A
%%
%% UD@ExtractFirstArgABCDE yields AB
%%.............................................................................
newcommandUD@RemoveTillUD@SelDOm%
longdefUD@RemoveTillUD@SelDOm#1#2UD@SelDOm#1%
newcommandUD@ExtractFirstArg[1]%
 romannumeral0%
 UD@ExtractFirstArgLoop#1UD@SelDOm%
%
newcommandUD@ExtractFirstArgLoop[1]%
 expandafterUD@CheckWhetherNullexpandafterUD@firstoftwo#1%
 #1%
 expandafterUD@ExtractFirstArgLoopexpandafterUD@RemoveTillUD@SelDOm#1%
%
%%=============================================================================
%% ReplaceEveryHash<argument>%
%%
%% Each explicit catcode-6(parameter)-character-token of the <argument> 
%% will be replaced by its stringification.
%%
%% You obtain the result after two expansion-steps, i.e., 
%% in expansion-contexts you get the result after "hitting" 
%% ReplaceEveryHash by two expandafter.
%% 
%% As a side-effect, the routine does replace matching pairs of explicit
%% character tokens of catcode 1 and 2 by matching pairs of curly braces
%% of catcode 1 and 2.
%% I suppose this won't be a problem in most situations as usually the
%% curly braces are the only characters of category code 1 / 2...
%%
%% This routine needs detokenize from the eTeX extensions.
%%-----------------------------------------------------------------------------
newcommandReplaceEveryHash[1]%
 romannumeral0UD@ReplaceEveryHashLoop#1%
%
newcommandUD@ReplaceEveryHashLoop[2]%
 UD@CheckWhetherNull#1 #2%
 UD@CheckWhetherLeadingSpace#1%
 expandafterUD@ReplaceEveryHashLoop
 expandafterUD@removespace#1#2 %
 %
 UD@CheckWhetherBrace#1%
 expandafterexpandafterexpandafterUD@PassFirstToSecond
 expandafterexpandafterexpandafter%
 expandafterUD@PassFirstToSecondexpandafter%
 romannumeral0expandafterUD@ReplaceEveryHashLoop
 romannumeral0UD@ExtractFirstArgLoop#1UD@SelDOm%
 #2%
 expandafterUD@ReplaceEveryHashLoop
 expandafterUD@firstoftwo#1%
 %
 expandafterUD@CheckWhetherHash
 romannumeral0UD@ExtractFirstArgLoop#1UD@SelDOm#1#2%
 %
 %
 %
%
newcommandUD@CheckWhetherHash[3]%
 expandafterexpandafterexpandafterUD@CheckWhetherNull
 expandafterexpandafterexpandafter%
 expandafterUD@firstoftwo
 expandafterexpandafterstring#1%
 expandafterexpandafterexpandafterUD@CheckWhetherNull
 expandafterexpandafterexpandafter%
 expandafterUD@firstoftwo
 expandafterexpandafterdetokenize#1%
 expandafterUD@ReplaceEveryHashLoop
 expandafterUD@firstoftwo#2#3#1%
 %
 expandafterexpandafterexpandafterUD@PassFirstToSecond
 expandafterexpandafterexpandafterexpandafterUD@Exchange
 expandafterstring#1#3%
 expandafterUD@ReplaceEveryHashLoop
 expandafterUD@firstoftwo#2%
 %
 %
 %
 expandafterUD@ReplaceEveryHashLoop
 expandafterUD@firstoftwo#2#3#1%
 %
%
%----------------------------------------------------------------------

newcommandallowhash[1]ReplaceEveryHash#1

newcommandallowanddetokenizehash[1]%
 detokenizeexpandafterexpandafterexpandafterReplaceEveryHash#1%
%

makeatother

begindocument
allowhashOne hash: #, not two

begingroup
frenchspacing
ttfamily allowanddetokenizehashOne hash: #, not two. This time in braces:#####
endgroup

For comparison the effect of verb|detokenize| without prior hash-replacing:

begingroup
frenchspacing
ttfamily detokenizeOne hash: #, not two. This time in braces:#####
endgroup

enddocument

documentclassarticle
makeatletter
defallowhash%%%%
 bgroupeveryeofegroupcatcode35=11relaxscantokens%
makeatother
begindocument
allowhashOne hash: #, not two

enddocument

or in a macro as requested in comments

documentclassarticle
makeatletter
defallowhash%%%%
 bgroupcatcode35=11relaxafterassignmentegroupgdeffoo%
makeatother
begindocument
allowhashOne hash: #, not two

[foo] [foo]
enddocument

When scantokens acts, the # characters are already doubled, because they're absorbed as the argument to a macro.

With the l3regex module of expl3 it's easier:

documentclassarticle
usepackagexparse

ExplSyntaxOn

NewDocumentCommandallowhashm
 
 tl_set:Nn l_tmpa_tl #1 
 regex_replace_all:nnN cP# cO# l_tmpa_tl
 tl_use:N l_tmpa_tl
 
ExplSyntaxOff

begindocument

allowhashOne hash: #, not two

enddocument

You can easily add support for saving the token list in a macro.

documentclassarticle
usepackagexparse

ExplSyntaxOn

NewDocumentCommandallowhashom
 
 tl_set:Nn l_tmpa_tl #2 
 regex_replace_all:nnN cP# cO# l_tmpa_tl
 IfNoValueTF #1 
 tl_use:N l_tmpa_tl 
 tl_set_eq:NN #1 l_tmpa_tl 
 

ExplSyntaxOff

begindocument

allowhashOne hash: #, not two

allowhash[foo]One hash: #, not two

textttmeaningfoo

enddocument

(There seems to be a double space in the picture, but it's only due to nonfrenchspacing.)